Saravanan666/pypi-org huggingface dataset:
Package: photomaker
PhotoMakerPhotoMakeris a library to create funny pictures with your friends' photos.Installationpip install photomakerExamplesfromphotomakerimport*MainKronos=Nonesomeone=Nonewithopen("documentation/input/me.jpeg",'wb')asf:MainKronos=f.read()withopen("documentation/input/someone.jpeg",'wb')asf:someone=f.read()MainKronossomeoneBurnMainKronosis on fire.withopen("output.gif",'wb')asf:f.write(burn(MainKronos))SaltMainKronosneeds to be salty.withopen("output.gif",'wb')asf:f.write(salt(MainKronos))TrashMainKronosis actually trash.withopen("output.png",'wb')asf:f.write(trash(MainKronos))DeleteIt is better to deleteMainKronos.withopen("output.png",'wb')asf:f.write(delete(MainKronos))HitlerMainKronosis worst than Hitler.withopen("output.png",'wb')asf:f.write(hitler(MainKronos))RIPMainKronosis dead.withopen("output.png",'wb')asf:f.write(rip(MainKronos))FacepalmMainKronosis facepalming.withopen("output.png",'wb')asf:f.write(facepalm(MainKronos))LeaderMainKronosis a good leader.withopen("output.png",'wb')asf:f.write(leader(MainKronos))BeautifulMainKronosis really beautiful.withopen("output.png",'wb')asf:f.write(beautiful(MainKronos))AffectMainKronosis the worst.withopen("output.png",'wb')asf:f.write(affect(MainKronos))KissMainKronoskissessomeone.withopen("output.png",'wb')asf:f.write(kiss(MainKronos,someone))SpankMainKronosspankssomeone.withopen("output.png",'wb')asf:f.write(spank(MainKronos,someone))BedMainKronossays thatsomeoneis worse than a monster.withopen("output.png",'wb')asf:f.write(bed(MainKronos,someone))
Package: photomatrix
OverviewSimple command-line application which concatenates a list of photos into a single photo
showing them in a matrix (in other words, a grid).InstallationFirst of all, you needPython3.7 or greater installed in your system.Then, asphotomatrixis a command line application, open a terminal and be ready to type commands.Install automatically with pipphotomatrixis available from the Python Package Index (PyPI), so installable
withpip:pip3 install photomatrixYou should now havephotomatrixavailable in your shell. For example, print the command help:photomatrix -hBuild locallyAlternatively, you can build locally from source code. First, clone this project from Github.Cd into the root folder.Create a virtual environment (e.g. namedmy_env) and activate it:python3 -m venv my_venv
source my_venv/bin/activateInstall the dev dependencies and the app dependencies into the virtual environment:pip3 install -r requirements_dev.txt
pip3 install -e .Run like this:python3 -m photomatrix -hUsageThe basic usage is:photomatrix INPUT_IMAGES OUTPUT_IMAGEwhere all the images found in the specified input path will be loaded, sorted, combined in a matrix
and the result will be written in the specified output path.Further options that you can customize are:Number of rows vs columnsResize and cropSortingBorderText to print (e.g. filename or Exif original date)See the command help (with-h) for more info on these options.ExamplesThe following examples use these test input images:up toMatrix with borderTo build a matrix with a simple border:photomatrix "data/input/*.jpg" data/output/matrix_border.jpg --border-width-ratio 0.1resulting in:Matrix sorted and with textTo build a matrix with inverse filename order, printing the filename in top center position:photomatrix "data/input/*.jpg" data/output/matrix_sort_text.jpg --sort filename_desc --text-type filename --text-position top_centerresulting in:Integration TestsRun the integration tests with:python3 -m pytest tests/integration
Package: photomosaic
[![Build Status](https://travis-ci.org/danielballan/photomosaic.svg)](https://travis-ci.org/danielballan/photomosaic)Assemble thumbnail-sized images from a large collection into a mosaic which,
viewed at a distance, gives the impression of one large photo.Documentation: [http://danielballan.github.io/photomosaic/docs/](http://danielballan.github.io/photomosaic/docs/)Related Work[John Louis Del Rosario](https://github.com/john2x) also has a
[photomosaic project](https://github.com/john2x/photomosaic) in Python. I
studied his code while I began writing version 0.1.0 of this project in 2012,
and there were similarities. Version 0.2.0 (2016) is a complete rewrite that
takes a fundamentally different approach.
Package: photon-ablog
ThePHOTON platform - ablogis forked fromhttps://github.com/sunpy/ablogat v0.10.25ABlog is a Sphinx extension for generating a log oriented static site. It
can be easily integrated with documentation for Python modules.I am planning a major refactoring of this project, mostly to integrate it into a larger set of requirements. This will probably result in breaking changes to any further updates from SunPy.
Package: photonai-graph
photonai-graphPhoton Graph is an extension for the PHOTON framework that allows for the use of machine learning based on graphs. Furthermore, the Graph Utilities contain a wide variety of functions that allow for the visualization and converting of graphs.DocumentationYou can find a detailed documentation here:https://wwu-mmll.github.io/photonai_graph/InstallationTo install photonai-graph create a dedicated conda/python environment and activate it. Then install photonai-graph viapipinstallphotonai-graphTo be able to use all modules of the toolbox you will still need to install tensorflow, dgl, pytorch and grakel according to your system configuration, for example withpipinstalltensorflow
pipinstalltorch
pipinstalldgl
pipinstallgrakelFor graph embeddings the gem python package is needed, along with tensorflow. Please install tensorflow according to your system.pipinstallnxt-gem
pipinstalltensorflowFor graph kernels the grakel package needs to be installed. You can install grakel via pip.pipinstallgit+https://github.com/ysig/GraKeL.git@cfd14e0543075308d201327ac778a48643f81095'For graph neural networks pytorch and deep graph library are required. You can install them via pippipinstalltorch
pipinstalldgl
Package: photonai-neuro
PHOTONAI NeuroPHOTONAI Neuro is an add-on module to simplify machine learning analyses for multimodal Magnetic Resonance Imaging (MRI)
with PHOTONAI.
Overall, this module combines the functionality of the famousNilearnpackage
with the pipeline structure ofPHOTONAI.Project setupInstall the latest version directly via pip:pip install photonai-neuroFeaturesEasy access to common brain masks and atlases.Simple syntax for building neuro-pipelines.All PHOTONAI advantages like hyperparemter optimization, model sharing, results visualization, and much more.
Package: photo-namer-nautilus
DescriptionPhoto namer for use in Nautilus. It works with data imported
by CatGrab photo import software.LicenseMIT LicenseNotesUse is of your own risk! It may corrupt you data.Only for use with data generated by CatGrab (http://www.digital.elements.li/de/pages/home/#FotoImportundArchivierung)Use it only as Nautilus script.Only tested on Ubuntu with python3Featuresnames selected and related files (e.g. JPG and his RAW file)afterwards raw file namingInstallationInstall / DeinstallDo not use sudo!with pippip3 install --user photo-namer-nautilus

1. pip3 uninstall photo-namer-nautilus
2. then remove script manually from ~/.local/share/nautilus/scripts/or setup.pyUnpack your package.Open a terminal and change to the folder which contains the setup.py and typepython setup.py install --userSetupTest it first!For testing copy some real data in a test directoryUsageget this readme with: photo_namer.py –helpFirst use the script only with test data until you are sure it works as expected.execute the script within the file manager and name your selected files. Then check if all related where also named in the same way.to name all related files with the current file name of the selected files type: *** (three stars).HintsThe logfile is stored in you home directory: ~/.photo-namer.log
Package: photonbend
PhotonbendPhotonbend is a python module to handle photos, especially photos taken with fisheye lenses, and convert them between different kinds of lenses, FoV, and types of photos like inscribed circles, cropped circles, or even side-by-side double inscribed circles. It also allows you to rotate those photos, convert them to equirectangular panoramas or convert panoramas to fisheye photos.It can be used as a library to handle images on your projects or it can be used as a standalone tool with its own set of commands to help you alter your photos taken with afisheye lens, anomnidirectional camerasuch as the Samsung Gear 360 or anequirectangularpanorama.If you just want to use the tools go to theScripts. If you want to undestand how it works just keep readingConceptsFisheye photographyUnlike rectilinear lenses, fisheye lenses can capture great angles like 180º and even greater. With the right setup we can nowadays produce 360º images.A 360º fisheye photo with its center aiming at the ceiling.[^1]Those type of images follow a scheme like the one below:Fisheye photo scheme depicting the angles produced by an equidistant lensHow it worksThis module uses the information you provide about the image format, lenses, and FoV, couples it with mathematical functions that describes the ways the lenses behave, and makes use of trigonometry to map your planar photos or panoramas to a sphere (actually, the interior wall of a sphere.
Using a sphere as a base lets you rotate the image. Using all those functions and trigonometry, it also lets you take a virtual picture of the interior of the sphere using different sorts of lenses and FoV to produce new images. It also lets you map a sphere to an equirectangular panorama.You can see examples on thescripts pageConventionOn the case of the images this software was designed to handle, the convention we adopted was the the center of the image is the top of the sphere, and its borders are the maximum angle of the FoV (In case of a 360 degree image, the sphere's bottom).This convention is important to understand the rotation scheme.RotationThis tool lets you rotate your images. For reference, the rotation is defined in 3 degrees of freedom, namely: pitch, yaw and roll, and their direction of rotation are those shown in the image below:For reference, on the scheme above, we are visualizing the image sphere looking down from its top.ScriptsThe module installs a a script 3 different commands to help you deal with your images.make-photoalter-photomake-pano[^1]:
## About the source image used on the examples:Author: Bob Dass <br>
Title: View From The Deck <br>
Available at: https://flickr.com/photos/54144402@N03/50677156243/in/faves-195024173@N05/ <br>
License: Creative Commons - Attribution 2.0 <br>
[License summary here](https://creativecommons.org/licenses/by/2.0/) <br>
[License text here](https://creativecommons.org/licenses/by/2.0/legalcode) <br>
Package: photonflux
Photonflux 0.2.3Photonflux is a photonic circuit simulation tool for simple, extensible simulation of large active photonic systems.It solves the problem that existing simulation tools are unable to capture many important phenomena that are key to creating working products including:Complex active component modelsComponent variation and Monte-Carlo simulationThermal crosstalk between componentsFabry-Perot reflections from on-chip componentsHere, we build a circuit simulator on NetworkX, a complex network solver, to enable arbitrarily reconfigurable circuit models and systems.
As opposed to other approaches, circuits / schematics are defined using a netlist generated from alayout. The primary reason for this is that photon designers typically do not use a idea -> schematic -> layout -> fabrication flow, but often skip the schematic step entirely (idea -> layout -> fabrication). The reason for this is that layouts in photonics are expressive and contain far more detail about the operation of systems than a schematic would capture.Layouts for simulation in photonflux are defined in a yaml markup format that can be automatically generated using.To see examples of what is possible in photonflux please seeour examples.For more information on the future of the package seeour roadmap.InstallationInstallation for new photonflux userspython -m pip install photonflux --upgradeInstallation for developersFirst install the package from github using:git clone https://github.com/alexsludds/photonflux.gitThen, navigate to the download directory and install as an editable python packagepython -m pip install -e .Getting startedWe include several examples in the examples folder, but if your usecase is not there please create an github issue and we can work together on it.AcksContributors (in chronological order):Alex Sludds (MIT): Initial code and documentation.
Package: photon-geocoder
Photon GeocoderOverviewPhoton Geocoder is a Python library designed to provide efficient and easy-to-use geocoding capabilities using OpenStreetMap data. It offers a robust solution for translating addresses into geographic coordinates and vice versa.FeaturesLeverage OpenStreetMap data for accurate geocoding.Support for various geocoding queries, including address, city, and postal code lookups.Ability to filter results by specific OpenStreetMap tags.Asynchronous API for efficient network operations.InstallationTo install Photon Geocoder, run the following command:pip install photon-geocoderUsageHere's a quick example of how to use Photon Geocoder:fromphoton_geocoderimportPhotonGeocoder# Create a geocoder instancegeocoder=PhotonGeocoder()# Geocode an addressaddresses=awaitgeocoder.query("Brandenburg Gate, Berlin")print(addresses)API ReferenceThe main class in Photon Geocoder isPhotonGeocoder. It provides the following methods:query(address, layers=None, osm_tags=None, limit=10): Performs a geocoding query.ContributingContributions to Photon Geocoder are welcome! Please read our contribution guidelines for more information on how to contribute.LicensePhoton Geocoder is licensed under theMIT License.
Package: photongui
PhotonGUITable of contents:PhotonGUIIntroductionInstallTutorialExamplesSupportIntroductionphotonguiis a cross-platform tool that allows you to create Python programs withHTML,CSS,JavaScript.photonguiusestkinterfor creating the window andcefpythonas embedded browser.photonguiis available only for Python 3. It is recommended to use versions3.5+.InstallpipinstallphotonguiTutorialSee ThedocsExamplesSee theExamplesSupport
Package: photonic
Photonic Utilities LibraryDescriptionPhotonic is the library where I upload all my neat tools!_loggingThis package is designed to make logging easier and customizable.Quick start:You need to configure your logger before using it, here is an example:logger_name = "my_logger"console_config(logger_name)  # This makes the logger log to the console (with colors)!
json_file_config(logger_name)  # This makes the logger log to a json file (more detailed too).Now, we are all set! To use the logger all you need to do is:logger = getLogger("my_logger")logger.debug(f"Test Message from logger.debug")
logger.info(f"Test Message from logger.info")
logger.warning(f"Test Message from logger.warning")
logger.error(f"Test Message from logger.error")
logger.critical(f"Test Message from logger.critical")This code will log the messages to both the console and the json file.You can use custom formats for the message or the provided formats in the logging.formatters.Format enum.utilsUtils are a group of functions that are nice to have ready for you.
Note: the functions currently in the package are meant to be used as a decorator.
Example:@threaded
def treaded_function():
    # some codeNow,threaded_functionwill start in a new thread whenever called.enumsThis package is a place where I put enums that I might use in the future.
Currently, it has one enum calledAnsiColorwhich contains some of the colors used in the console.
Example:print(AnsiColor.red.value + "Example Error Text." + AnsiColor.reset.value)Contact Me!If you have any suggestions to add to the library you canemail me.
I am open to any constructive criticism!
Package: photon-ml
Photon: Machine Learning FrameworkA end-to-end Machine Learning ramework that extends the functionality of other frameworks such as TensorFlow & Keras. Photon ML is built to apply neural network and ensemble modeling techniques for deep learning financial algorithms. The framework supports the entire lifecycle of a machine learning project including data preparation, model development, training, monitoring, evaluation and deployment.Key Features of Photon ML:Streamlines the development and implementation of end-to-end Machine Learning systems.Custom object-oriented API with built-in subclassing of Keras and TensorFlow APIs.Built-in custom modules such as Models, Layers, Optimizers and Loss Functions.Highly customizable interface to extend built-in modules for specific algorithms/networks.Detailed logging and analysis of model parameters to increase interpretability and optimization.Works natively with TensorFlow distributed strategies.Real-time data preprocessing; dataset splitting, normalization, scaling, aggregation & resampling.Custom batching, padding and masking of data.Designed to be model/algorithm agnostic and to work natively with container services.Natively shares input & output between multiple networks to streamline deep ensemble learning.Interface for saving, serializing and loading entire networks including learned & hyper parameters.Custom dynamic learning rate scheduling.Photon ML Examples:https://github.com/sequenzia/photon_examplesA Collection of Algorthims/Models designed with Photon ML:https://github.com/sequenzia/dyson
Package: photon-observer
Photon ObserverTools for working with thePhoton protocol.Example:importpysharkimportiofromphoton_observerimportPhotonLayer,FragmentBuffer,CommandType,ReliableMessagedefon_message(message:ReliableMessage):passdefmain():capture=pyshark.LiveCapture("wlp4s0",bpf_filter="udp")buf=FragmentBuffer()forpincapture.sniff_continuously():payload=bytes.fromhex(p.udp.payload.replace(":",''))layer=PhotonLayer.unpack(io.BytesIO(payload))forcmdinlayer.commands:ifcmd.type==CommandType.SendReliableType:msg=cmd.reliable_message()on_message(msg)elifcmd.type==CommandType.SendUnreliableType:_cmd=cmd.unreliable_type()msg=_cmd.reliable_message()on_message(msg)elifcmd.type==CommandType.SendReliableFragmentType:msg=cmd.reliable_fragment()result=buf.offer(msg)ifresultisnotNone:msg=result.reliable_message()on_message(msg)else:continuePSAdditional thanks to @hmadison for hisphoton_spectatorpackageLicenseThis project is licensed under MIT. Contributions to this project are accepted under the same license.
Package: photon-packet-parser
photon-packet-parserThephoton-packet-parseris a Python library designed to parse and analyze packets transmitted using thePhoton Protocol16based on the C# library coded by0blu. This library provides developers with a convenient way to decode and inspect Photon Protocol packets in their Python applications.WarningThis library is incomplete as I merely needed some parts of it for my own project. I will add more features as I need them. It is not fully tested and far from being used in a production environment. If you need a feature that is not implemented yet, feel free to open an issue or submit a pull request.FeaturesParsing and decoding of Photon Protocol packetsCallbacks for handling different packet actionsAccess to packet headers, payload, and metadataInstallationYou can install thephoton-packet-parserlibrary using pip:pipinstallphoton-packet-parserUsageTo use the library, start by importing the PhotonPacketParser class:fromphoton_packet_parserimportPhotonPacketParserThen, create an instance of the PhotonPacketParser class and provide the necessary callbacks:defon_event(header,payload):# Callback for handling event packetspassdefon_request(header,payload):# Callback for handling request packetspassdefon_response(header,payload):# Callback for handling response packetspassparser=PhotonPacketParser(on_event,on_request,on_response)Once the parser object is created, you can use the handle_payload method to parse a payload:payload_data=b'\x01\x02\x03\x04\x05\x06\x07\x08'parser.handle_payload(payload_data)The library will invoke the appropriate callback based on the packet type encountered during parsing.For more advanced usage and customization options, please refer to the documentation.ExamplesParsing a Photon Protocol packetfromphoton_packet_parserimportPhotonPacketParserdefon_event(header,payload):# Handle event packetsprint("Received event packet")defon_request(header,payload):# Handle request packetsprint("Received request packet")defon_response(header,payload):# Handle response packetsprint("Received response packet")# Create a parser instance with callbacksparser=PhotonPacketParser(on_event,on_request,on_response)# Parse a payloadpayload_data=b'\x01\x02\x03\x04\x05\x06\x07\x08'parser.handle_payload(payload_data)ContributingContributions to the photon-packet-parser library are welcome! If you find any bugs, have feature requests, or want to contribute improvements, please open an issue or submit a pull request on the GitHub repository.When contributing, please follow the existing code style and ensure that all tests pass before submitting your changes.LicenseThe photon-packet-parser library is licensed under the MIT License. You are free to use, modify, and distribute this library in accordance with the terms of the license.AcknowledgementsThis library was inspired by0bluimplementation and the need for a Python parser.
Package: photon-ptm
[![Build Status](https://travis-ci.org/jdrudolph/photon.svg?branch=master)](https://travis-ci.org/jdrudolph/photon)PHOTON is available as part of the [Perseus](https://www.perseus-framework.org) software for proteomics analysis starting from Perseus version 1.6.2.1.[![Lecture explaining the main concepts behind PHOTON](https://img.youtube.com/vi/JXhZyWA3JIc/0.jpg)](https://www.youtube.com/watch?v=JXhZyWA3JIc)# Elucidation of Signaling Pathways from Large-Scale Phosphoproteomic Data Using Protein Interaction NetworksPhosphoproteomic experiments typically identify sites within a protein that are differentially phosphorylated between two or more cell states. However, the interpretation of these data is hampered by the lack of methods that can translate site-specific information into global maps of active proteins and signaling networks, especially as the phosphoproteome is often undersampled. Here, we describe PHOTON, a method for interpreting phosphorylation data within their signaling context, as captured by protein-protein interaction networks, to identify active proteins and pathways and pinpoint functional phosphosites. We apply PHOTON to interpret existing and novel phosphoproteomic datasets related to epidermal growth factor and insulin responses. PHOTON substantially outperforms the widely used cutoff approach, providing highly reproducible predictions that are more in line with current biological knowledge. Altogether, PHOTON overcomes the fundamental challenge of delineating signaling pathways from large-scale phosphoproteomic data, thereby enabling translation of environmental cues to downstream cellular responses.[Pubmed link](https://www.ncbi.nlm.nih.gov/pubmed/28009266)# Intallation and TutorialFollow the [installation instructions](docs/Perseus/installation.md) and
[learn](docs/Perseus/tutorial.md) how to use PHOTON from within Perseus.# FormulasPlease feel free to ask questions on the code and formulas used. [Here](docs/formulas.ipynb) you can find more detailed information.# Troubleshooting
Please open an issue [here](https://github.com/jdrudolph/photon/issues), or
contact me directly if you have issues with installing or using PHOTON.# Licence
If the current [licence](/LICENCE.txt) does not suit your needs,
please contacte me for alternative licencing options.# Contiribute
Constributions to the code and the documentation of PHOTON are welcome!