Saravanan666/pypi-org huggingface dataset:
Package: artific
An algorithm visualization pip package for PythonExplore the docs »Table of ContentsGetting StartedInstallationAlgorithmsSortingBubblesortHeapsortInsertionsortSearchingLinear searchBinary searchNotebooksTODOAcknowledgmentsGetting StartedInstallationStable releaseTo install artific, run this command in your terminalpip install artificThis is the preferred method to install artific, as it will always install the most recent stable release.If you don't havepipinstalled, thisPython installation guidecan guide
you through the process.AlgorithmsSortingBubblesortfrom artific import BubbleSort

arr = [90,6,2,55,67,2,0,12,92,5,76,2,9,3]
arr = BubbleSort(arr)

arr.visualize()
print(arr)Output[0, 2, 2, 2, 3, 5, 6, 9, 12, 55, 67, 76, 90, 92]The code above will generate the following GIFInsertionsortfrom artific import InsertionSort

arr = [90,6,2,55,67,2,0,12,92,5,76,2,9,3]
arr = InsertionSort(arr)

arr.visualize()
print(arr)Output[0, 2, 2, 2, 3, 5, 6, 9, 12, 55, 67, 76, 90, 92]The code above will generate the following GIFHeapsortfrom artific import HeapSort

arr = [90,6,2,55,67,2,0,12,92,5,76,2,9,3]
arr = HeapSort(arr)

arr.visualize()
print(arr)Output[0, 2, 2, 2, 3, 5, 6, 9, 12, 55, 67, 76, 90, 92]The code above will generate the following GIFSearchingLinear searchfrom artific import LinearSearch

arr = [90,6,2,55,67,2,0,12,92,5,76,2,9,3]
obj = LinearSearch(arr,1)

obj.visualize()
print(obj)Output3The code above will generate the following GIFLinear searchfrom artific import BinarySearch

arr = [0, 2, 2, 2, 3, 5, 6, 9, 12, 55, 67, 76, 90, 92]
obj = LinearSearch(arr,55)

obj.visualize()
print(obj)Output9The code above will generate the following GIFTODOSearchingGraph AlgorithmsTreesAcknowledgmentsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: artificer
Getting Startedcd <directory containing this file>$VENV/bin/pip install -e .$VENV/bin/initialize_artificer_db development.ini$VENV/bin/pserve development.iniTODO
Authentication
Authoring
Export Script
Import Script@view_config(route_name=’artifacts’, renderer=’json’)
@view_config(route_name=’labels’, renderer=’json’)
@view_config(route_name=’supported_os’, renderer=’json’)
@view_config(route_name=’sources’, renderer=’json’)
@view_config(request_method=’GET’, route_name=’artifact’, renderer=’json’)
@view_config(request_method=’DELETE’, route_name=’artifact’, renderer=’json’)
@view_config(request_method=’PUT’, route_name=’artifact’, renderer=’json’)
@view_config(request_method=’POST’, route_name=’artifacts’, renderer=’json’)
@view_config(route_name=’export_artifacts’, renderer=’string’)
@view_config(route_name=’import_artifacts’, renderer=’json’)
@view_config(route_name=’home’, renderer=’../templates/mytemplate.jinja2’)config.add_route(‘home’, ‘/’)
config.add_route(‘artifacts’, ‘api/artifacts’)
config.add_route(‘artifact’, ‘api/artifacts/{id}’)
config.add_route(‘labels’, ‘api/labels’)
config.add_route(‘supported_os’, ‘api/supported_os’)
config.add_route(‘sources’, ‘api/sources’)
config.add_route(‘export_artifacts’, ‘api/export’)
config.add_route(‘import_artifacts’, ‘api/import’)0.0Initial version
Package: artificial-artwork
Neural Style Transfer - CLICreate artificial artwork by transfering the appearance of one image (eg a famous painting) to another
user-supplied image (eg your favourite photograph).+=Uses a Neural Style Transfer algorithm to transfer the appearance, which you can run though a CLI program.Neural Style Tranfer(NST) is an algorithm that applies thestyleof an image to thecontentsof another and produces ageneratedimage.
The idea is to find out how someone, with thepainting styleshown in one image, would depict thecontentsshown in another image.NST takes acontentimage (eg picture taken with your camera) and astyleimage (eg a picture of a Van Gogh painting) and produces thegeneratedimage.This Python package runs a Neural Style Tranfer algorithm on inputcontentandstyleimages to producegeneratedimages.buildpackagecontainerizationcode qualityDocs:https://boromir674.github.io/neural-style-transfer/OverviewThis package exposes a configurable NST algorithm via a convenient CLI program.Key features of the package:Selection of style layers at runtimeIterative Learning Algorithm using the VGG Deep Neural NetworkSelection of iteration termination condition at runtimeFast minimization of loss/cost function with parallel/multicore execution, using TensorflowPersisting of generated imagesQuick-startRun a demo NST, on sampleContentandStyleImages:mkdir art
export NST_HOST_MOUNT="$PWD/art"

docker-compose up

# Process runs, in containerized environment, and exits.Check out yourGenerated Image!Artificial Artwork:art/canoe_water_w300-h225.jpg+blue-red_w300-h225.jpg-100.pngxdg-open art/canoe_water_w300-h225.jpg+blue-red_w300-h225.jpg-100.pngUsageRun thenstCLI with the–helpoption to see the available options.docker run boromir674/neural-style-transfer:1.0.2 --helpDevelopmentInstallationInstallnstCLI andartificial_artworkpython package frompypi`:pip install artificial_artworkOnly python3.8 wheel is included atm.Sample commands to install the NST CLI from source, using a terminal:git clone https://github.com/boromir674/neural-style-transfer.git

pip install ./neural-style-transferThe Neural Style Transfer - CLI heavely depends on Tensorflow (tf) and therefore it is crucial that tf is installed correctly in your Python environment.
Package: artifician
ArtificianArtifician is an event driven library developed to simplify and speed up the process of preparation of the datasets for Artificial Intelligence models.Getting StartedPre-requisitespythonv3.6or laterInstallationBinary installers for the latest released version are available at the Python Package Index (PyPI) and on Conda# or PyPIpipinstallartifician# condacondainstall-cplato_solutionsartificianDocumentationPlease visitAritfician DocsUsagefromartifician.datasetimport*fromartifician.feature_definitionimport*fromartifician.processors.normalizerimport*defextract_domain_name(sample):"""function for extracting the path from the given URL"""domain_name=sample.split("//")[-1].split('/')[0]returndomain_nameinput_data=['https://www.google.com/','https://www.youtube.com/']dataset=Dataset()# initializing dataset objecturl_domain=FeatureDefinition(extract_domain_name,dataset)# initializing feature_definition and passing extractor function name as a parameter and subscribing it to datasetnormalizer=Normalizer(PropertiesNormalizer(),url_domaindelimiter={'delimiter':["."]})# Initializing normalizer (processor) and passing properties normalizer as a parameter and subscribing it to url_domain""" Now we are all set to go, all we have to do is call add_samples method on the dataset object and pass the input dataafter calling the add_samples, url_domain will start its execution and extract the data using extract_domain_name function, as soon url_domainfeature is processed normalizer will start it execution and furthur is will process the data extracted by url_domain. The processed data is thenpassed back to the dataset. Following diagram will make it more clear for you. """prepared_data=dataset.add_samples(input_data)print(prepared_data)Output010https://www.google.com/[(www, 0), (google, 1), (com, 2)]1https://www.youtube.com/[(www, 0), (youtube, 1), (com, 2)]
Package: artilipy
Artilipy is an official API wrapper written in PythonThe library is made for easier interactions with Artilities API using Python. The library is maintained by Artilities Team.Installation:pipinstallartilipyClient initialisation example:fromartilipyimportclient# client initartilities_client=client.Client()# generate an ideagenerated_idea=artilities_client.generate_idea()You can find more examples on the GitHub page of the package.Explore other open-source projects provided by Artilities team:https://github.com/artilities
Package: artipull
Website Reader LibraryThe Website Reader Library is a Python library that allows you to read the HTML content of a website and extract the core text contents (usually the article for news pages). It uses the popular Python librariesrequests,re, andBeautifulSoup.InstallationYou can install the Website Reader Library usingpip:pip install website-readerpython
Copy codeUsagefromArtiPullimportread_website# Provide the URL of the website you want to readurl="https://example.com"text=read_website(url)# Extracted text content from the inner-most HTML tagsprint(text)FunctionalityThe read_website(url) function takes a URL as input and returns the text content from the inner-most HTML tags of the website. It uses requests library to make a GET request to the URL, BeautifulSoup library to parse the HTML content, and regular expressions (re) to extract the text content from inner-most tags.LicenseThis library is released under the MIT License. See LICENSE for more information.ContributingIf you find any issues or have suggestions for improvements, please feel free to contribute to this project by opening an issue or submitting a pull request. Contributions are welcome!AuthorsThis library is developed and maintained by Nick Kraftor.
Package: artiq
ARTIQ (Advanced Real-Time Infrastructure for Quantum physics) is the next-generation control system for quantum information experiments.
It is developed byM-Labsfor and in partnership with theIon Storage Group at NISTas free software.
It is offered to the entire research community as a solution equally applicable to other challenging control tasks outside the field of ion trapping.The system features a high-level programming language that helps describing complex experiments, which is compiled and executed on dedicated hardware with nanosecond timing resolution and sub-microsecond latency. It includes graphical user interfaces to parametrize and schedule experiments and to visualize and explore the results.ARTIQ uses FPGA hardware to perform its time-critical tasks.
It is designed to be portable to hardware platforms from different vendors and FPGA manufacturers.
Currently, one configuration of alow-cost open hardware FPGA boardand several different configurations of ahigh-end FPGA evaluation kitare used and supported.
Any of these FPGA platforms can be combined with any number of additional peripherals, either already accessible from ARTIQ or made accessible with little effort.Custom hardware components with widely extended capabilities and advanced support for scalable and fully distributed real-time control of experimentsare being designed.ARTIQ and its dependencies are available in the form ofconda packagesfor both Linux and Windows.
Packages containing pre-compiled binary images to be loaded onto the hardware platforms are supplied for each configuration.
Like any open source software ARTIQ can equally be built and installed directly fromsource.ARTIQ is supported by M-Labs and developed openly.
Components, features, fixes, improvements, and extensions are funded by and developed for the partnering research groups.Technologies employed includePython,Migen,MiSoC/mor1kx,LLVM/llvmlite, andQt5.Website:https://m-labs.hk/artiqCite ARTIQasBourdeauducq, Sébastien et al. (2016). ARTIQ 1.0. Zenodo. 10.5281/zenodo.51303.Copyright (C) 2014-2017 M-Labs Limited.ARTIQ is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.ARTIQ 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 ARTIQ.  If not, see <http://www.gnu.org/licenses/>.
Package: artiruno
Artiruno is a program to help you make decisions with verbal decision analysis. It’s also a Python library with a class forpreordered setsthat should be just as useful outside the context of decision-making.Try Artiruno in your web browserDocumentationLicenseThis program is copyright 2021, 2022 Kodi B. Arfer.This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.This program 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 theGNU General Public Licensefor more details.
Package: artisan-builder
Artisan is a lightweight experiment-management library with support for gradual
typing. It allows you to write code like this:classSineWave(artisan.Artifact):'sin(2πf⋅t + φ) for t ∈ [0, 1sec), sampled at 44.1kHz.'classSpec(Protocol):f:float;'Frequency'φ:float=0.0;'Phase shift'def__init__(self,spec:Spec)->None:self.t=np.linspace(0,1,44100)self.x=np.sin(2*np.pi*spec.f*self.t+spec.φ)to generate file trees like this:├──SineWave_0000/│├──_meta_.json│├──t.cbor│└──x.cbor└──SineWave_0001/├──_meta_.json├──t.cbor└──x.cborthat can be viewed as customizable, live-updated, interactive documents like
this:– artisan-ui screenshot –to facilitate an explorable, explainable, composable-component-based approach to
scientific, analytical, and artistic programming. Complete documentation is
available onRead the Docs.Installation>pipinstallartisan-builderArtisan works with CPython and PyPy 3.6+.DevelopmentTo install the project’s dependencies:InstallPython 3.6+.InstallPoetry.Runpoetry install –no-root.To run the test suite:> poetry run pytestTo build the HTML documentation:> poetry run task build-docsTo build the HTML documentation with live-previewing:> poetry run task serve-docs
Package: artisinal-integers
artisinal_integersget a unqiue artisinal integer from one of many providersInstallation$ pip install artisinal_integersUseCurrently you can create integers from Brooklyn Integers. By default you can fetch a single integer, or set the "num" parameter to the number of integers you want, limit 10!import artisinal_integers

artisinal_integers.create_brooklyn_integer(4)
Package: artist
In shortArtist is a 2D plotting library for Python.  It’s main focus is the
output.  Artist creates a LaTeX file which can be included in your paper
or thesis.  The code needs TikZ and PGFPlots to compile and your plots
will tightly integrate with your main text.  Artist provides an
easy-to-use and clean Python interface and can compile your plot
on-the-fly as a stand-alone PDF file.For instance thecosmic-ray flux spectrum:See thedocumentationfor tutorials.RationaleArtist enables you to visualize the results of your data analysis.  The
quality of your plots should reflect the quality of your analysis.  With
most software, this is hardly possible and the term ‘publication quality’
takes on an entirely new meaning.  As a result, many papers and theses
suffer from inconsistent and generally poor-quality plots.Fortunately, some solutions are available.  For LaTeX users, one can use
PGF/TikZ for generating figures and plots.  This ensures a very consistent
display throughout your document.  PGFPLOTS builds on that to provide a
user-friendly interface for many kinds of plots and to allow extensive
customization.For many users, however, it is more convenient to use a programmatic
interface from your favorite programming language.  For Python, such an
interface is available in Artist.Artist can be used in place of other plotting libraries, but the output is
a LaTeX file requiring PGF/TikZ and PGFPLOTS.  Previewing the output is
possible by means of a simple method which renders the plot as a PDF.The style of the plots is based on the work of William S. Cleveland.Developer notes: releasing a new versionIf you’re ready to release a new version, make sure to follow these steps:Update the version numbers in both thesetup.pyand thedoc/conf.pyfilesTag a release version using git, or directly on GitHubUpdate the documentation by compiling, committing it to thegh-pagesbranch and pushing it to GitHub:$ make gh-pages
$ git push origin gh-pagesPush a new version to the Python Package Index (PyPI):$ python setup.py sdist upload(make sure to have a valid .pypirc file)Thanks.
Package: artistools
ArtistoolsArtistools is collection of plotting, analysis, and file format conversion tools for theARTISradiative transfer code.InstallationRequires Python >= 3.10artistools can be installed from PyPI using `pip install artistools'. For development, clone the repository and make an editable install:gitclonehttps://github.com/artis-mcrt/artistools.gitcdartistools
python3-mpipinstall-e.
pre-commitinstallUsageType "artistools" at the command-line to get a full list of commands. The most frequently used commands are:artistools plotspectraartistools plotlightcurveartistools plotestimatorsartistools plotnltepopsartistools describeinputmodelUse the -h option to get a list of command-line arguments for each command. Most of these commands would usually be run from within an ARTIS simulation folder.Example outputLicenseDistributed under the MIT license. SeeLICENSEfor more information.https://github.com/artis-mcrt/artistoolsCiting ArtistoolsIf you make use of artistools please cite it. For details, seehttps://zenodo.org/badge/latestdoi/53433932.
Package: artmation
ARTAboutAdvance Recon Tool is a tool custom build to automate the process of reconnaisance while doing bug hunitng on a target.It uses various other tools such as assetfinder, waybackurls, gau and arjun, so that you don't need to run them seperately.Pre-RequisitesPython3 (3.9.9 preferred)Golang version >=1.16Installation -pip install ART-ReconRunning the codeart -d url -hContactIf you have any suggestion/advice/problemContact:Instagram
Package: artmr
artmrartmr is a simple text-only, fully off-line timing application designed for
small-scale manual competition timing. Heavily based (i.e. shamelessly copied)
on asciimatics contact list demo and inspired by classic DOS utilities.InstallationInstall withpip install artmr. Currently tested only on Linux and Mac.
Start the program withartmr. If you encounter errors about "Unknown locale: UTF-8, add
these lines to~/.bash_profile:export LC_ALL=en_US.UTF-8
export LANG=en_US.UTF-8A (colour, UTF-8) terminal window of > 100 columns is recommended.UsageLoad a start list with the command line option-c, format isnumber,name,category,team,
one per line. You can also load a start list with F3 from the start list screen.
Names and numbers should be unique and categories are optional but free-form. Seecompetitors.example.txtfor an example file.Use the Start List view to mark actually starting competitors and then continue on
to the Timing screen.Start the race with the Start (spaceors) button from the Timing screen
and add a new split/finish time with Split (spaceors). Add a competitor bib number
with Edit (e). Jump between start list and splits with Tab. Category filter can be
accessed with F2. You can still add competitors while the race is running from the
start list. All competitors will have the same start time.Start time and splits are saved on disk so you can quit the application and data
is kept. Times are rounded to whole seconds.You can export the results withx. This creates[competition name]_[category]_[time].csvfile in
the current directory in formatrank,elapsed time,difference,number,name,category,team. Export will
contain the selected category.To start a new race, use--resetcommand line option. Previous data is destroyed.
Alternatively, you can take a backup of the~/.artmr/results_1.dbfile and keep a safe copy
of the results.ScreenshotsTODOsplash screenmake a UI for multiple competitions, database already supports thissupport for lap timingchange competitor model to be many-to-many via a Participation tableWindows supportautomatic data export/sync to other services
Package: ar_too
========ar_too========Artifactory configuration toolFeatures--------* Update Artifactory LDAP settings* Add or update repositories to Artifactory* Set the 'admin' passwordUsage-----* Update repositoriesTo update or create repositories, you must have a directory with individualjson files for each desired repository. Then, point the tool at the directory,and it will create all the repos therein. Each json file should be set up asper https://www.jfrog.com/confluence/display/RTF/Repository+Configuration+JSONi.e:`ar_too --url http://artifactory.company.com --username admin --password password configure --repos_dir /tmp/repos`* Update LDAP settingsTo update the LDAP settings, you'll need to create an ldap file(see examples/ldap.json). Then, simply run the command and pass the file location.i.e.:`ar_too --url http://artifactory.company.com --username admin --password password configure --ldap_json /tmp/ldap.json`The LDAP settings json is basically a json implementation of the ldap portionof this xml doc:  https://www.jfrog.com/public/xsd/artifactory-v1_4_5.xsd.The way this application works is download the current xml, compare the ldapsettings to the desired ldap settings, and send an update (which is the wholesystem config) if they're different.* Update the admin passwordUpdating the admin password is staight-forward. Simply pass the string you wantto update the password to. Note this will be visible in your command line history.`ar_too --url http://artifactory.company.com --username admin --password password configure --admin_pass newpassword`
Package: arts
项目描述对 Python 开发中常用功能的封装。作者信息昵称：江南雨上主页|微信|Github|PyPi|邮箱|捐赠开源许可本项目由多个子版块组成，每个子版块采用各自的开源协议，而没有设置统一的针对整个项目的开源协议。每个子版块的根目录中都放置了各自的开源许可文件 LICENSE ，如未放置，则表明该子版块不是开源的。
Package: artsapiclient-ds3478
artsapiclient_ds3478API Client for the Art Institute of Chicago's API which provides JSON formatted data as a REST style service that allows developers to explore and integrate the museum's public data into their projects.Installation$pipinstallartsapiclient_ds3478UsageTODOContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licenseartsapiclient_ds3478was created by Donald Stephens. It is licensed under the terms of the MIT license.Creditsartsapiclient_ds3478was created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: artssat
artssatartssat provides a high-level, object-oriented interface for theAtmospheric Radiative Transfer Simulator. The aim of artssat is to provide a simpler and more modular way of performing radiative transfer simulations and in particular retrievals.As of now, artssat is only used for my own research on remote sensing retrievals but I hope to
be able to expand its capabilities over time.DocumentationSource code documentation is hosted on the projectsGithub pages site.