Saravanan666/pypi-org huggingface dataset:
Package: patchwork-contrib
Patchwork ContribSet of tools and helpers to integratePatchworkwith external
libraries.Warning!Current project state should be considered as Proof-of-Concept.This framework is based on working solution which handles 100+ services and hundreds of events per second,
however it's written from scratch and fully asynchronous in opposite to original one which is fully synchronous.
There is no guarantee that this framework pass performance tests and will be useful.https://patchwork-framework.gitlab.io/contrib
Package: patchwork-core
Patchwork CoreCore package of Patchwork - an asynchronous distributed microframework.This library contains some core structures and utils to re-use over all Patchwork
packages.RequirementsPython 3.7Contribution notes.. warning::
Remember to runcompile-protocscript after every change in proto files fromprotocoldirectory.
Make sure that all these changes follow guidelines described in Google Protobuf v3 documentation.Installationpip install patchwork-coreDocumentationhttps://patchwork-framework.gitlab.io/core
Package: patchworkdocker
Patchwork DockerPurposeAllows a Docker build to be easily changed, without having to clone and modify an existing build repository.FeaturesAll with a single command, the tool can:Build images from a different base image.Add/override files in the build context.Apply patches to the Dockerfile or other files in the build context.Define a different Dockerfile.Use CasesA few basic use cases (./docker-run.shcan be used instead ofpatchworkdocker):To change a base image fromdebian:stretchtopython:3.7-stretchso as to get the latest version of Python in the
image with no hassle:patchworkdockerbuildexample:1.0.0https://github.com/example/docker-example.git\--base-imagepython:3.7-stretchAdd an alternate Dockerfile to a pre-existing context:patchworkdockerbuildexample:1.0.0https://github.com/example/docker-example.git\--additional-fileDockerfile:Dockerfile.example\--dockerfileDockerfile.exampleChange the URL of a piece of software that gets installed into a Docker image:patchworkdockerbuildexample:1.0.0https://github.com/docker-library/python.git\--dockerfile3.7/stretch/Dockerfile\--patchchange-install-url.patch:DockerfileRaspberry Pi users may find this tool particularly useful as, outside the official images, there is often need to
change image build in order to get them to work on the non-standard rpi architectures.InstallationPrerequisitesDockerPython 3.7+ (optional, as can be run entirely from Docker if you don't have Python 3.7)The tool can be installed directly from GitHub:pipinstallgit+https://github.com/colin-nolan/patchwork-docker@master#egg=patchworkdockerUsageUp-to-date usage information can be seen with:patchworkdocker--help
patchworkdockerbuild--help
Package: patek
PatekA collection of reusable pyspark utility functions that help make development easier!InstallationPatek is available on PyPI and can be installed with pip:pipinstallpatekUsageIO HelpersPatek provides a set of IO helpers to quickly read and write data from/to various sources in PySpark.Dynamic Delta Table WriterThe superDeltaWriter function allows you to write data to a Delta table using the merge capability without having to write out every single update and merge condition. This is useful when you have a large number of columns and/or a large number of update conditions.frompatek.ioimportsuperDeltaWritersuperDeltaWriter(sparkDataframe,['key_column1'],'delta/path',sparkSession,sparkContext,['update_col1','update_col2'])If update columns are not specified, the default is to update all non-key columns that exist in both the source and target tables. Also, if the target table does not exist, it will be created.Funnel.io Schema to Spark SchemaThe funnelSparkler function allows you to convert a Funnel.io schema to a Spark schema. This is useful to remove ambiguity when reading data from Funnel.io exports into spark dataframes, without having to manually define the schema.frompatek.ioimportfunnelSparklerdataframe=funnelSparkler('path/to/funnel_schema.json','path/to/funnel_export_data',sparkSession,sparkContext,data_file_type='csv')Utility FunctionsPatek provides a set of utility functions to help make development easier.Determine Key CandidatesThe determine_key_candidates function allows you to determine the key candidates for a given dataframe. This is useful when you have a large number of columns in a dataframe and you want to quickly determine which columns are good candidates for a key.frompatek.utilsimportdetermine_key_candidateskey_candidates=determine_key_candidates(sparkDataframe)print(key_candidates)# Output:# a list containing single column key candidates: ['column1', 'column2', 'column3']# a list containing composite key candidates: [['column1', 'column2'], ['column1', 'column3']]Clean Column NamesThe column_cleaner function allows you to clean column names in a dataframe. It removes special characters and replaces spaces with underscores.frompatek.utilsimportcolumn_cleaner# input dataframe columns: ['column?? 1', 'column: 2', 'column-3']cleaned_dataframe=column_cleaner(sparkDataframe)# output dataframe columns: ['column_1', 'column_2', 'column_3']
Package: patelier
A Japanese text-line analyzing packageFunctionThis project is to analyze text lines written in Japanese.You can provide the text lines by selecting a text file.The text file needs to be encoded inUTF-8orShift-JIS.Each control code (0x00-0x1f) in the text lines is changed to ‘▲’.For example, a tab code in the text lines is changed to ‘▲’.The analysis result is displayed.This “patelier” is still under development.Maybe in the future,the patelier may be able to display more informationby analyzing text lines.I hope the patelier helps you a little.Development StatusPre-Alpha (experiment)Necessary EnvironmentMicrosoft Windows 10(Tested with 64 bit version)Python Ver. 3.7 or later(Tested with Ver. 3.9.0)pip(Installed with Python) (Tested with Ver. 22.0.4)Preferred  EnvironmentGoogle ChromeorMicrosoft EdgeDependencyeel(Tested with Ver. 0.14.0)mecab-python3(MeCab) (Tested with Ver. 1.0.5)natsort(Tested with Ver. 8.1.0)pyperclip(Tested with Ver. 1.8.2)python-docx(Tested with Ver. 0.8.11)pywin32(win32com) (Tested with Ver. 304)regex(Tested with Ver. 2022.4.24)Setupcommand:py -m pip install patelier

(for upgrade)
py -m pip install -U patelierUsagecommand:patelierAutherK2UNITLicenseThis software is released under the MIT License, see LICENSE.txt.NotesThis “patelier” is supposed to be used in Japan.The patelier is still under development.So, the patelier may suddenly be unpublished,and the license terms may be changedin the future (eg to the Apache license 2.0, etc.).
Package: patella
patellauses Flask to host an interactive html/css/js frontend through which users can navigate to
data and plot it.Flask Url Pathspatellauses the  httpGETandPOSTcommands to send data between
one page and another. The homepage paths are/and/indexfrom which you can
navigate to the rest of the front end.Install and Run Directionspatellais uploaded to the pip package repository.To install, simply runpip install patella. Arequirements.txtfile that comes with the
package specifies its dependencies. Install these withpip install-rrequirements.txt. It is
recommended you run this in a virtual environment so as not to interfere with previous installations.To start the Flask server, runpatella startup <URL>, where URL is the path
to be prepended to the page url. Next, use a browser to browse to127.0.0.1:4444.
To access the service from other computers on the same network, use the public ip of the host
computer on port 4444. From these two addresses the webservice can be accessed as long as the server is running.FilesLog FilesA log file will be generated in the path that you run the webservice from namedwebservice.log. this file includes server reloads, error reporting, logs get
and post requests and debugger pins.POSTandGETlogs are timestamped, but others are notData FilesData files from the webservice will be downloaded to adata/directory created at runtime in the directory the
server is started from. In that directory, all files downloaded from the webservice will be browseable.
Package: paten
PatenPaten is a framework for azure functions written in Python. Paten provides:A command line tool for creating, building, deploying azure functions.A decorator based API integrated with in/out bindings.installinstallpatenpackage.$pipinstallpatenIn addition,Azure CLIandAzure Functions Core Toolsare required.
See below to install the libraries.Azure CLIAzure Functions Core ToolspreparationBefore deploying to Azure,az loginis required.$azlogin

Youhaveloggedin.Nowletusfindallthesubscriptionstowhichyouhaveaccess...QuickstartIn your project directory, type below.
Directory {function_app_name} and example python scripts are created.$patennew-app{function_app_name}Then, modifyapp.py, like below.importazure.functionsasfuncfrompatenimportPatenapp=Paten('{function_app_name}')@app.http_trigger('req',methods=['GET'],route='/')@app.out_http()defexample_http_function(req:func.HttpRequest)->func.HttpResponse:name=req.params.get('name')# responsereturnfunc.HttpResponse(name)Before deploying to azure functions, you can test your functions on local with the command below.$patenlocalFinally, to deploy to azure functions, type below in the directory{function_app_name}.
The files are generated in./{function_app_name}/.patenand your function app is deployed to azure.$patendeploysupport bindingsservicestriggerinouthttpO-OblobOXXqueueOX0timerO--O: supportedX: not supported yet-: officially not supported
Package: patent-client
SummaryA powerful library for accessing intellectual property, featuring:🍰Ease of use:All sources use a simple unified API inspired byDjango-ORM.🐼Pandas Integration:Results are easily castable toPandas Dataframes and Series.🚀Performance:Fetched data is retrieved using thehttpxlibrary with native HTTP/2 and asyncio support, and cached using thehishellibrary for super-fast queries, andyankeefor data extraction.🌐Async/Await Support:All API's (optionally!) support the async/await syntax.🔮Pydantic v2 Support:All models retrieved arePydantic v2 modelswith all the goodness that comes with them!Docs, including a fulsome Getting Started and User Guide are available onRead the Docs. The Examples folder includes examples of usingpatent_clientfor
many common IP tasksCoverageUnited States Patent & Trademark OfficePatent Examination Data- Full SupportGlobal Dossier- Full SupportPatent Assignment Data- Lookup SupportPatent Trial & Appeal Board API v2- Supports Proceedings, Decisions, and DocumentsPatent Public Search- Full SupportBulk Data Storage System- Full SupportEuropean Patent Office - Open Patent ServicesInpadoc - Full SupportEPO Register - No Support (in progress)Classification - No SupportFree software: Apache Software License 2.0Installationpip install patent_clientIf you only want access to USPTO resources, you're done!
However, additional setup is necessary to access EPO Inpadoc and EPO Register resources. See theDocs.Quick StartTo use the project:# Import the model classes you need>>>frompatent_clientimportInpadoc,Assignment,USApplication# Fetch US Applications>>>app=USApplication.objects.get('15710770')>>>app.patent_title'Camera Assembly with Concave-Shaped Front Face'# Fetch from USPTO Assignments>>>assignments=Assignment.objects.filter(assignee='Google')>>>len(assignments)>23000True>>>assignment=Assignment.objects.get('47086-788')>>>assignment.conveyance_text'ASSIGNMENT OF ASSIGNORS INTEREST'# Fetch from INPADOC>>>pub=Inpadoc.objects.get('EP3082535A1')>>>pub.biblio.title'AUTOMATIC FLUID DISPENSER'Async Quick StartTo use the asyncio methods, simply useasync withfor iterators, and call any methods with aaprefix:apps=list()asyncforappinUSApplication.objects.filter(first_named_applicant="Google"):apps.append(app)app=awaitUSApplication.objects.aget("16123456")DocumentationDocs, including a fulsome Getting Started are available onRead the Docs.DevelopmentTo run the all tests run:pytestA developer guide is provided in theDocumentation.
Pull requests welcome!Related projectsPython EPO OPS ClientGoogle Public Patent DataPatentsView API WrapperUSPTO Scrapy Scraper
Package: patentmodels
Patent Models=============Functions and datamodels for patent data.Usage--------------``from patentmodels import PatentDoc, Description, Claimset, Claims, Classification``Getting a bag of words from a patent description.::text = [("Lorem ipsum dolor sit amet, consectetur ""adipiscing elit. Integer nec odio. \n"),("Praesent libero 100. Sed cursus 102 ante dapibus diam. ""Sed nisi. \n"),("Sed, dignissim lacinia, <nunc>. Curabitur tortor 2.""Pellentesque nibh. \n"),"Quisque volutpat 554 condimentum velit."]desc = Description(text)desc.bag_of_words()Provides:::['lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consecteturadipisc', 'elit','integ', 'nec', 'odio', 'praesent', 'libero', 'sed', 'cursu', 'ant', 'dapibu','nisi', 'sed', 'dignissim', 'lacinia', 'nunc', 'curabitur', 'tortor', 'nibh','quisqu', 'volutpat', 'condimentum', 'velit']For a complete patent document:::claims = [Claim("Claim {0} has an x.".format(num), num)for num in range(1, 10)]claimset = Claimset(claims)desc = Description(["one", "two", "three"])fig = Figures()classification = Classification("A")pd = PatentDoc(claimset,desc,fig,"Title",classification,"20010101010")pd.reading_time()pd.claimset.get_claim(5).text
Package: patent-parsing-tools
[![Build Status](https://travis-ci.org/pprzetacznik/patent-parsing-tools.svg?branch=master)](https://travis-ci.org/pprzetacznik/patent-parsing-tools)
[![Documentation Status](https://readthedocs.org/projects/patent-parsing-tools/badge/?version=latest)](https://patent-parsing-tools.readthedocs.io/en/latest/?badge=latest)
![patent-parsing-tools CI](https://github.com/pprzetacznik/patent-parsing-tools/workflows/patent-parsing-tools%20CI/badge.svg)## Documentation[Read the docs](https://patent-parsing-tools.readthedocs.io/en/latest/)## System requirements:`Bash sudo yum installpython-devellibxslt-devellibxml2-devel`## Python requirements:`Bash pip install-rrequirements.txt `## Running:Collecting and serializing data:`Bash python-mpatent_parsing_tools.supervisor [working_directory] [train_destination] [test_destination] [year_from] [year_to] `Eg.`Bash python-mpatent_parsing_tools.supervisor patents/working_directory patents/train_destination patents/test_destination 2014 2015 `Generating dictionary with train set:`Bash python-mpatent_parsing_tools.bow.dictionary_maker [train_directory] [max_parsed_patents] [dict_max_size] [dictionary_name] `Eg.`Bash python-mpatent_parsing_tools.bow.dictionary_maker patents/train_destination 1000000000 4096 dictionary.txt `Generate bag of words with train set and test set:`Bash python-mpatent_parsing_tools.bow.bag_of_words [directory_with_serialized_patents] [destination_directory] [dictionary.txt] [package_size > 1024] `Eg.`Bash python-mpatent_parsing_tools.bow.bag_of_words patents/train_destination patents/final_dataset_train dictionary.txt 1048576 python-mpatent_parsing_tools.bow.bag_of_words patents/test_destination patents/final_dataset_test dictionary.txt 1048576 `## Running tests`Bash python-munittest discover . `
Package: patentpy
patentpy: Access USPTO data in Rectangular FormatCIstatusLinux Traviscode coverageOverviewThe patentpy package allows easy access to USPTO (United States Patent and Trademark Office) bulk patent data in rectangular format. By downloading, converting, and storing patent data directly from the USPTO website, patentpy minimizes the work needed to acquire usable data, allowing users to focus on analyzing the data. The R version of this can be found athttps://github.com/JYProjs/patentr.Installation# install from PyPIpipinstallpatentpy# To install development version# clone repository then run follow code from its parent directorypipinstall./patentpyNote: This package utilizes pybind11 to wrap a custom txt parser written in C++ code, lxml to parse xml files, and pandas for the option of presenting uspto bulk data as a dataframe.Sample codeBulk patent data in TXT or XML format (1976+) can be downloaded using the year and week (within each year) as follows:# import get_bulk_patent_data functionalityfrompatentpy.acquireimportget_bulk_patent_data# download patents from the first week of 1976 and get data framepatent_data=get_bulk_patent_data(year=1976,week=1)# download patents from the last 5 weeks of 1980# and store in a CSV file named "patent-data.csv"# Note: uspto patent data is reported on Tuesdays and 1980# has 53 Tuesdays, hence, 53 weeks worth of dataget_bulk_patent_data(year=[1980]*5,week=range(49,54),output_file="patent-data.csv")FunctionalityData collected for each patentunique identifier (patent number - WKU)application datepatent issue datepatent titleinventor name(s)assignee name(s)ICL classification (IPC or Locarno)referenced patent numbersclaimsAPI Documentationhttps://jyprojs.github.io/patentpy/index.htmlContributeTo contribute to patentpy, you can create issues for any bugs/suggestions on theissues page.
You can also fork the patentpy repository and create pull requests to add features you think will be useful for users.CitationYu J, Wadhwa RR, Beltz H, Desai MY, Scott JG, Érdi P. patentpy: Access USPTO Bulk Data in Rectangular Format. 2021; Python package version 0.1.0. URLhttps://github.com/JYProjs/patentpy.
Package: path
path(aka path pie, formerlypath.py) implements path
objects as first-class entities, allowing common operations on
files to be invoked on those path objects directly. For example:frompathimportPathd=Path("/home/guido/bin")forfind.files("*.py"):f.chmod(0o755)# Globbingforfind.files("*.py"):f.chmod("u+rwx")# Changing the working directory:withPath("somewhere"):# cwd in now `somewhere`...# Concatenate paths with /foo_txt=Path("bar")/"foo.txt"Path pie ishosted at Github.Findthe documentation here.Guides and TestimonialsYasoob wrote the Python 101Writing a Cleanup Scriptbased onpath.AdvantagesPath pie provides a superior experience to similar offerings.Python 3.4 introducedpathlib,
which shares many characteristics withpath. In particular,
it provides an object encapsulation for representing filesystem paths.
One may have imaginedpathlibwould supersedepath.But the implementation and the usage quickly diverge, andpathhas several advantages overpathlib:pathimplementsPathobjects as a subclass ofstr, and as a
result thesePathobjects may be passed directly to other APIs that
expect simple text representations of paths, whereas withpathlib, one
must first cast values to strings before passing them to APIs that do
not honorPEP 519PathLikeinterface.pathgive quality of life features beyond exposing basic functionality
of a path.pathprovides methods likermtree(from shlib) andremove_p(remove a file if it exists), properties like.permissions,
and sophisticatedwalk,TempDir, andchmodbehaviors.As a PyPI-hosted package,pathis free to iterate
faster than a stdlib package. Contributions are welcome
and encouraged.pathprovides superior portability using a uniform abstraction
over its single Path object,
freeing the implementer to subclass it readily. One cannot
subclass apathlib.Pathto add functionality, but must
subclassPath,PosixPath, andWindowsPath, even
to do something as simple as to add a__dict__to the subclass
instances.pathinstead allows thePath.moduleobject to be overridden by subclasses, defaulting to theos.path. Even advanced uses ofpath.Paththat
subclass the model do not need to be concerned with
OS-specific nuances.path.Pathobjects are inherently “pure”,
not requiring the author to distinguish between pure and non-pure
variants.This path project has the explicit aim to provide compatibility
withpathlibobjects where possible, such that apath.Pathobject is a drop-in replacement forpathlib.Path*objects.
This project welcomes contributions to improve that compatibility
where it’s lacking.OriginsThepath.pyproject was initially released in 2003 by Jason Orendorff
and has been continuously developed and supported by several maintainers
over the years.For EnterpriseAvailable as part of the Tidelift Subscription.This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.Learn more.
Package: pathable
AboutObject-oriented pathsKey featuresTraverse resources like pathsAccess resources on demand with separate accessor layerUsagefrompathableimportDictPathd={"parts":{"part1":{"name":"Part One",},"part2":{"name":"Part Two",},},}dp=DictPath(d)# Concatenate paths with /parts=dp/"parts"# Stat path keys"part2"inparts# Open path dictwithparts.open()asparts_dict:print(parts_dict)
Package: pathaia
PathAIASimple digital pathology analysis tools.Basic Usage•Advanced features•Docs•Community•LicensePathAIA aims to standardize and automate most of WSI analysis in digital pathologyIf you feel like you keep rewriting the same code over and over again when working on Whole Slide Images and you wish there were a nicely integrated library to automate all this, you came to the right place. With PathAIA we aim to create a fast, high level and modular library to work on WSI at scale in order to perform image analysis or to create a well rounded dataset for your machine learning project.Basic UsageStep 0: InstallSimple installation from PyPIpipinstallpathaiaStep 1: Import pathaia's patch extraction toolfrompathaia.patchesimportpatchify_folder_hierarchicallyStep 2: Define your extraction parametersYou can extract at multiple pyramid levels with a hierarchical structure between patches of different levels. You can control pretty much every extraction parameter you like, from patch size to interval between patches or filters to chose which patch to extract. You can also decide whether you want to save patches as png or just extract coordinates in csv.infolder="/path/to/input/slide/folder"outfolder="/path/to/output/patches/folder"top_level=5low_level=0psize=224interval={"x":224,"y":224}silent=list(range(low_level,top_level+1))extensions=[".svs"]recurse=Falseslide_filters=["full"]verbose=2With these parameters you will find all svs slides that are directly ininfolderand extract patch coordinates from levels 0 to 5 with a hierarchical structure. No png image will be stored assilentlists all levels. Patches will be contiguous with size 224 and will only be extracted from tissue zone that are determined by filtering on slide thumbnails. Withverbose=2thumbnails of extracted areas are also stored on disk.Step 3: Extract !patchify_folder_hierarchically(infolder,outfolder,top_level,low_level,psize,interval,silent=silent,extensions=extensions,recurse=recurse,slide_filters=slide_filters,verbose=verbose,)Output csv will look like :idparentlevelxydxdyPatch identifierParent identifierint (0, max level)intintintint#1None200996996#1#1#1100448448#1#1#1#1#1000224224#1#1#2#1#100224224224.....................Advanced featuresYou can use more advanced features to work on slides, most notably using your custom filters. Checkdocumentationfor more info.CommunityThe lightning community is maintained by 4 core contributors fromInstitut Universitaire du Cancer de Toulouse - Oncopole:Arnaud AbreuPilar OrtegaRobin SchwobKevin CortaceroAsking for helpIf you have any questions please:Read the docs.Check existing issues, oradd a new issueLicensePlease observe the GNU GPL 3.0 license that is listed in this repository.BibTeXIf you want to cite the framework feel free to use this.@article{pathaia2021,title={PathAIA},author={Abreu, A and .al},journal={GitHub. Note: https://github.com/ArnaudAbreu/PathAIA},volume={3},year={2021}}