Saravanan666/pypi-org huggingface dataset:
Package: pyezxl
This module is for easily read/write with EXCEL using Python.The target is for easily control for EXCEL.Therefore pyezxl is focused to control easily as follows.the function name is consist of 3 parts (action_target_role)read_range_valuewrite_cell_valuedelete_cell_valuefunction name is linked with underbar(_) and text is all lowcaseaction words : read, write, Insert, delete, change, set, copy, movetarget words : range, sheet, x, y, linerole words : name, color, value, endword definitionread: when you want to read cell valuecheck : read some data except cell value as like color, font etcwrite : when you want to write cell valueset : write some data except cell value as like color, line etccell : 1 cellrange : minimum 2 cells and overweb-site : please visit for more informationwww.halmoney.comsimple exampleWhen you want to input [A1]=”sujin”import pyezxlexcel = pyezxl.pyezxl(“”)excel.write_cell_value(“”,[1,1],”sujin”)When you want to input value in some rangeimport pyezxlexcel = pyezxl.pyezxl(“”)activesheet_name = excel.read_activesheet_name()my_range = [2,1,10,5][x1, y1, x2, y2 ] = excel.check_address_value(my_range)for x in range(x1, x2+1):for y in range(y1, y2+1):excel.write_cell_value(activesheet_name,[x, y],”sujin” )
Package: pyezzi
Compute the thickness of a solid using Yezzi and Prince method described in
the article “An Eulerian PDE Approach for Computing Tissue Thickness”, IEEE
TRANSACTIONS ON MEDICAL IMAGING, VOL. 22, NO. 10, OCTOBER 2003.[1]A C implementation by Rubén Cárdenes[2]helped me a lot writing this,
especially the anisotropic part.[1]http://dx.doi.org/10.1109/tmi.2003.817775[2]http://www.dtic.upf.edu/~rcardenes/Ruben_Cardenes/Software.htmlRequirementsnumpy, cython, scikit-image. Tested with Debian Jessie and Fedora 27,
miniconda-python 3.6, cython 0.24, numpy 1.11.2, scikit image 0.12.3Installation instructionAvailable on pypi.[3]Use pip:pip install pyezziAlternatively, clone the repository and build cython modules withpython setup.py build_ext--inplace.[3]https://pypi.python.org/pypi/pyezziUsagefrompyezziimportcompute_thicknessthickness=compute_thickness(labeled_image,debug=True)labeled_imageis a 3 dimensional numpy array where the wall is labeled 2
and the interior is labeled 1.Aspacingparameter specifying the spacing between voxels along the axes
can optionnaly be specified.Check out the included jupyter notebooks in theexamplefolder for more
details.Note on thickness solver implementationThe ordered traversal method mentioned in the original publication can be used
using theyezzi_solver='ordered'keyword argument. However, we found that
it introduces artifacts to the result. Also the implementation is in pure
python so it is slower to solve than the iterative algorithm.ContributionsFeel free to submit pull requests.
I know the code is nowhere near optimal as it is.LicenseThis work is licensed under the french CeCILL license.[4]You’re free to use and modify the code, but please cite the original paper and
me.[4]https://www.cecill.info/licences/Licence_CeCILL_V2.1-en.html
Package: pyf3d
About F3DF3D is a python package designed for high-resolution 3D image with kernels written in OpenCL. F3D achieves
platform-portable parallelism on modern multi-core CPUs and many-core GPUs. The interface and mechanisms to access F3D
accelerated kernels are written in Python to be fully integrated with other Python packages. F3D delivers several key
image-processing algorithms necessary to remove artifacts from micro-tomography data. The algorithms consist of data
parallel aware filters that can efficiently utilize resources and can process data out of core and scale efficiently
across multiple accelerators. Optimized for data parallel filters, F3D streams data out of core to efficiently manage
resources, such as memory, over complex execution sequence of filters. This has greatly expedited several scientific
workflows dealing with high-resolution images. F3D preforms two main types of 3D image processing operations:
non-linear filtering, such as bilateral and median filtering, and morphological operators (MM) with varying 3D
structuring elements.InstallationpyF3D requiresPyOpenCLto run. Seethislink for installation instructions.LinuxYou may install pyF3D with either conda or pip:condainstall-cals832pyf3dOr:pipinstallpyF3DCopyright NoticeF3D Image Processing and Analysis for Many- and Multi-core Platforms, Copyright (c) 2014, The Regents of the University
of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from the U.S.
Dept. of Energy).  All rights reserved.If you have questions about your rights to use or distribute this software, please contact Berkeley Lab’s Technology
Transfer Department atTTD@lbl.gov.NOTICE.  This software is owned by the U.S. Department of Energy.  As such, the U.S. Government has been granted for
itself and others acting on its behalf a paid-up, nonexclusive, irrevocable, worldwide license in the Software to
reproduce, prepare derivative works, and perform publicly and display publicly.  Beginning five (5) years after the
date permission to assert copyright is obtained from the U.S. Department of Energy, and subject to any subsequent five
(5) year renewals, the U.S. Government is granted for itself and others acting on its behalf a paid-up, nonexclusive,
irrevocable, worldwide license in the Software to reproduce, prepare derivative works, distribute copies to the public,
perform publicly and display publicly, and to permit others to do so.
Package: pyfaaster
pyFaaSterUseful Utilities for Python Functions as a Service (starting with AWS Lambda).ProblemFunctions as a Service can be joyful. When paired with a concise language like Python, you start to
rethink the need for a "web framework" like Rails, Django, etc: couple your functions with your
FaaS provider's API Gateway and you are off an running with minimal code. Of course, there is still some boilerplate code around injecting environment, formatting responses, checking arguments, etc.ConceptThe goal ofpyfaasteris to cut
through the cruft and get you humming along with your Python FaaS.pyfaasteraccomplishes
this goal by providing you with useful middleware (i.e. decorators) for your lambda functions. Additionally,pyfaastercan be used for its excellentMakefileandserverless.ymlexamples.Cheers!UsageThe following is a non-exhaustive list and details of the useful middleware. More can be found inpyfaaster.aws.handler_decorators.Environment VariablesYou don't want to sprinkleos.environthroughout your code. Let us do that for you.import pyfaaster as faas

@faas.environ_aware(['REQUIRED_ENV'], ['OPTIONAL_ENV'])
def handler(event, context, REQUIRED_ENV=None, OPTIONAL_ENV=None):
    assert REQUIRED_ENV == os.environ['REQUIRED_ENV']     # <- faas.environ_aware will return early with a useful message if this is not set
    assert OPTIONAL_ENV == os.environ.get('OPTIONAL_ENV')Configuration FilesSimilarly, don't worry about injecting those S3 Configuration files.import pyfaaster as faas

@faas.configuration_aware('config.json', True)   # S3 key to a config file, create if not there
def handler(event, context, configuration=None):
    assert configuration == < { 
    'load': lambda : {contents of config bucket},
    'save': lambda d : save d into config bucket,
    }Response FormatSigh, you have to manually convert your lambda return values to API Gateway's expected dictionary? Don't forget to serialize all your json into thebodyelement! Oh wait ... just useimport pyfaaster as faas

@faas.http_response(default_error_message='Failed to handle something.")
def handler(event, context, **kwargs):
    return { 'my': 'important', 'json': 'data'} # <- will end up as the json serialized `body` in an API Gateway compatible dict with statusCode.AuthorizationYou gotta confirm your token scopes, friend!import pyfaaster as faas

# Checks the event.requestContext.authorizer for the given scopes. This works nicely with AWS custom
# authorizers. An example one is coming to this library soon.

@faas.scopes('read:profile', 'update:email')
def handler(event, context, **kwargs):
    return 'Hello, Secure World!'
Package: pyfab
PYFAB - Python interface to the Fabber Bayesian model fitting toolFabber is a Bayesian model-fitting framework designed to fit nonlinear
parameterised models to timeseries data, particularly 4D fMRI data
such as ASL, CEST, DCE, DSC, etc.PYFAB offers a Python interface to the tool which can work with
the command line Fabber tool, or the shared library version,
depending on which is installed.Fabber must be installed before use - Seehttps://fabber_core.readthedocs.io/.
Fabber and a selection of models will be available in the upcoming
FSL 6.0.1 releaseFull documentation athttps://pyfab.readthedocs.io/
Package: pyfabdb
PyFABDBPyFABDB is a Python library to access theFlesh and Blood DB API. The Python library enables you to access all public Flesh and Blood DB API endpoints using Python.Install$ pip install pyfabdbExamples>>>frompyfabdbimportpyfabdb>>>fabdb=pyfabdb.PyFabdb()>>>card=fabdb.get_card(id="absorb-in-aether-red")>>>print(card["name"])AbsorbinAetherContributingAll help is welcomed!1. Setting up an environmentThe easiest way to set up a test environment is to run:tox --devenv venvsource venv/bin/activate2. Running all the testsAfter making your changes and creating new test for any changes, you will need to ensure all test pass. Running all the test can be done by runningtox -e py.3. Install pre-commitWith the environment created by tox, run:pip install pre-commitpre-commit install4. Create a pull requestsCreate a pull request following the pull request template. A maintainer will review the changes made, update the changelog and release the new version of pyfabdb.
Package: pyfabm
This folder contains source and build tools to compile and build FABM as a
python module. In addition a number of useful scripts are included.When configuring for compilation usingCMakeand additional
target ‘wheel’ is added - either in VisualStudio or in Makefile - depending
on platform. The taget ‘wheel’ will build a ‘.whl’ file that can be installed
usingpip.This is mainly for developers/release managers as a few additional steps are still required.It is the intention to have up-to-date wheels for some platforms onrelease.
Package: pyfabrik
pyfabrikPython 3 implementation ofFABRIK(Forward And
Backward Reaching Inverse Kinematics).Installationpip install pyfabrikUsageNOTE: API is still very unstable (until the 1.0 release). Suggestions are welcome.importpyfabrikfromvectormathimportVector3initial_joint_positions=[Vector3(0,0,0),Vector3(10,0,0),Vector3(20,0,0)]tolerance=0.01# Initialize the Fabrik class (Fabrik, Fabrik2D or Fabrik3D)fab=pyfabrik.Fabrik3D(initial_joint_positions,tolerance)fab.move_to(Vector3(20,0,0))fab.angles_deg# Holds [0.0, 0.0, 0.0]fab.move_to(Vector3(60,60,0))# Return 249 as number of iterations executedfab.angles_deg# Holds [43.187653094161064, 3.622882738369357, 0.0]GoalRoadmapBasic 2D (flat chain)Basic 3D (flat chain)3D testing sandboxBasic 2D joint movement restrictionsBasic 3D joint movement restrictionsComplex chain support 2DComplex chain support 3DContributingAll contributions are appreciated.Read the paperpaper.FABRIKshomepagehas links to other implementations.LicenseMIT LicenseCopyright (c) 2020 Saša Savić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: pyface
The Pyface project contains a toolkit-independent GUI abstraction layer,
which is used to support the “visualization” features of the Enthought Tool
Suite libraries.  Pyface contains Traits-aware wrappers of standard GUI
elements such as Windows, Dialogs and Fields, together with the “Tasks”
application framework which provides a rich GUI experience with dock panes,
tabbed editors, and so forth.  This permits you to write cross-platform
interactive GUI code without needing to use the underlying GUI backend.The following GUI backends are supported:PySide2 (stable) and PySide6 (experimental)PyQt5 (stable) and PyQt6 (in development)wxPython 4 (experimental)ExampleThe following code creates a window with a simple Python shell:frompyface.apiimportApplicationWindow,GUI,IPythonShellclassMainWindow(ApplicationWindow):""" The main application window. """#: The PythonShell that forms the contents of the windowshell=Instance(IPythonShell,allow_none=False)def_create_contents(self,parent):""" Create the editor. """self.shell.create(parent)returnself.shell.controldefdestroy(self):self.shell.destroy()super().destroy()def_shell_default(self):frompyface.apiimportPythonShellreturnPythonShell()# Application entry point.if__name__=="__main__":# Create the GUI.gui=GUI()# Create and open the main window.window=MainWindow(title="Python Shell",size=(640,480))window.open()# Start the GUI event loop!gui.start_event_loop()InstallationPyface is a pure Python package.  In most cases Pyface will be installable
using a simplepip installcommand.To install with a backend, choose one of the following, as appropriate:$pipinstallpyface[pyside2]$pipinstallpyface[pyside6]$pipinstallpyface[pyqt5]$pipinstallpyface[wx]Some optional functionality usespillowandnumpyand these can be
installed using optional dependencies:$pipinstallpyface[pillow]$pipinstallpyface[numpy]For running tests a few more packages are required:$pipinstallpyface[test]DocumentationOnline Documentation.API Documentation.Developing PyfaceTheetstool.pyscript provides utilities to assist developers wanting to work
on Pyface.  To use it, you will need to have the source checked out via Git,
Enthought’sEDMdistribution manager, and
a minimal environment containing at least theClicklibrary.You can then follow the instructions inetstool.py.  In particular:useetstool.py installto create environments for particular toolkits and
runtimesuseetstool.py shellto activate those environmentsuseetstool.py testto run the tests in those environmentsuseetstool.py flake8to perform style checksuseetstool.py docsto build the documentationuseetstool.py test-allto run the tests across all supported runtimes and toolkitsLicensePyface source code is licensed with a BSD-style license.  Some default images
are licensed with other licenses. See the license files for further
information.
Package: pyfaceb
=======pyfaceb=======Introduction------------This python library was started because most of the existing librariesout there are either no longer in development, use the old REST API, orare lacking in support of the more advanced features available, such asbatch querying and FQL support.Purpose-------1. to provide a lightweight, easy to use Python wrapper for the FacebookGraph API and Facebook Query Language (FQL) interface.2. to provide a nice API to Facebook's batch query interface.3. to make it easy to use multiple access tokens, where appropriate /necessary.Basic Usage Examples--------------------fbg = FBGraph('access-token')me = fbg.get('me')# prints your first nameprint me['first_name']# prints out the name of all your likesmy_likes = fbg.get('me/likes')for like in my_likes['data']:print like['name']# make a request with parameters...my_first_3_likes = fbg.get('me/likes', {'limit': 3})# get an object by it's ID #:facebook_platform_page = fbg.get('19292868552')Batched Query Examples----------------------# batched queries with a single access tokenfbg = FBGraph('access-token')# you can write it manually if you like...results = fbg.batch([{'method': 'GET', 'relative_url': 'me'},{'method': 'GET', 'relative_url': 'me/friends?limit=50'}])# or use the GetRequestFactorybatch = [GetRequestFactory('me'), GetRequestFactory('me/friends', limit=50)]fbg.batch(batch)# If you need to use multiple access tokens in# one batch call, you can!# Note, you still must specify a "fallback" token when you create an# instance of FBGraph()fbg.batch([GetRequestFactory('PAGE1_FB_OBJ_ID', access_token=PAGE1_ACCESS_TOKEN),GetRequestFactory('PAGE2_FB_OBJ_ID', access_token=PAGE2_ACCESS_TOKEN),GetRequestFactory('PAGE3_FB_OBJ_ID', access_token=PAGE3_ACCESS_TOKEN),])
Package: pyfacegen
A python library for several functions used in generating realistic facial meshes. Including:Mesh: A simple mesh class consisting of vertices and faces
IO: Read/write of .obj and .ply files
Alignment: Rigid ICP and non-rigid ICP
Other: Deformation transferInstallation instructionscreate and activate a virtual environmentrun the following comands (using anaconda)$ conda install numpy matplotlib scikit-learn scikit-imageinstall scikit-sparse with conda using
$ conda install -c conda-forge scikit-sparseif using .ply files install pyassimp using pip
$ pip install pyassimpTo verify installation use
$ python tests.py
Package: pyfaceit
PyfaceitPyfaceit is a Python Package that makes it easy to retrieve data from Faceit API for Counter Strike Developers. Faceit API docs can be confusing and hard to implement,this Python package does all the hard work behind the scenes, simply input the faceit name and retrieve all dat from a player, you can even retrieve specific map data.InstallationUse the package managerpipto install Pyfaceit.pipinstallpyfaceitUsageimportpyfaceit# Creates Instance of Pyfaceit Classinstance=pyfaceit.Pyfaceit(<faceitnameasstring>)# returns python Dict of all player datainstance.player_stats()# returns Python dict information of player information for specific map.instance.player_stats_map(<map_name(canbewithoutde_eg.'mirage'or'de_mirage')>)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.LicenseMIT
Package: pyfacerecall
pyfacerecallInstallationpipinstallpyfacerecallGenerate own face dataset using cameraYou can use cli built-in cli tool to generate dataset of your own face using your camera.python-mpyfacerecall--outputperson--source0How to use?frompyfacerecallimportFaceRecognitionif__name__=='__main__':model_path="model"image_path='test.jpeg'# if you already have model trained then no need to provide dataset path while initializing class like below# face_recognition = FaceRecognition(number_of_classes=2)face_recognition=FaceRecognition("./dataset/training","./dataset/testing")face_recognition.training()face_recognition.save_model(model_path)# get the model and do something with thatmodel=face_recognition.load_saved_model(model_path)# get the model predictionk,result=face_recognition.model_prediction(image_path,model_path,need_cropping=False)print(f"detected class is{k}and prediction percentage is{result}")
Package: pyfa-converter
pyfa-converterAllows you to convert pydantic models for fastapi param models - query, form, header, cookie, body, etc.How to install?pip install pyfa_converterHow to simplify your life?fromdatetimeimportdatetimefromtypingimportOptionalfromfastapiimportFastAPI,UploadFile,File,FormfrompydanticimportBaseModel,Fieldfrompyfa_converterimportFormDepends,PyFaDependsapp=FastAPI()classPostContractBodySchema(BaseModel):title:str=Field(...,description="Description title")date:Optional[datetime]=Field(None,description="Example: 2021-12-14T09:56:31.056Z")@app.post("/form-data-body")asyncdefexample_foo_body_handler(data1:PostContractBodySchema=PyFaDepends(model=PostContractBodySchema,_type=Form),document:UploadFile=File(...),):return{"title":data.title,"date":data.date,"file_name":document.filename}What do I need to do?frompyfa_converterimportPyFaDepends,FormDepends,QueryDependsfromfastapiimportHeader,Form...asyncdeffoo(data:MyCustomModel=PyFaDepends(MyCustomModel,_type=Header)):...asyncdeffoo(data:MyCustomModel=PyFaDepends(MyCustomModel,_type=Form)):...asyncdeffoo(data:MyCustomModel=FormDepends(MyCustomModel)):...asyncdeffoo(data:MyCustomModel=QueryDepends(MyCustomModel)):...If you want to accept a file on an endpoint, then the content-type for that endpoint changes from application/json to www-form-data.FastAPI does not know how to override the pydantic schema so that parameters are passed as form.
Even if you dofoo: CustomPydanticModel = Depends()all model attributes will be passed as query, but we want them to become body, that's what this library exists for.Usually you use something along the lines of:But, if we accept a lot of fields, then the function becomes very large (the number of attributes for the endpoint increases and it does not look very good).Thanks to this library, it is possible to force the conversion of Field fields into fields of FastAPI Form with full preservation of all attributes (alias, gt, te, description, title, example and more...)
Package: pyfa-converter-v2
pyfa-converter-v2Allows you to convert Pydantic models for FastAPI param models - query, form, header, cookie, body, etc.The project is originally written by dotX12 atdotX12/pyfa-converter,
but it doesn't support Pydantic v2, so we made a fork of the project with some changes:Added support for pydantic v2Added testsRe-licensed the code to LGPL 3.0Added mypy, flake8, isort checksRemoved dead codeThe project may be archived if the original package author upgrades to Pydantic v2
(dotX12/pyfa-converter#25).Currently, the library does not fully reflect the requirements in OpenAPI (e.g. gt parameter will be required, but this will not be specified in FastAPI docs).How to install?pip install pyfa_converter_v2How to simplify your life?fromfastapiimportFastAPIfrompydanticimportBaseModelfrompyfa_converter_v2importQueryDependsapp=FastAPI()classArticleSchema(BaseModel):title:strcontent:str@app.post("/article")asyncdefcreate_article(article:ArticleSchema=QueryDepends(ArticleSchema)):return{"id":1,"title":article.title,"content":article.content}