Saravanan666/pypi-org huggingface dataset:
Package: daachorse
python-daachorsedaachorseis a fast implementation of the Aho-Corasick algorithm using the compact double-array data structure.
This is a Python wrapper.InstallationInstall pre-built package from PyPIRun the following command:$ pip install daachorseBuild from sourceYou need to install the Rust compiler followingthe documentationbeforehand.
daachorse usespyproject.toml, so you also need to upgrade pip to version 19 or later.$ pip install --upgrade pipAfter setting up the environment, you can install daachorse as follows:$ pip install git+https://github.com/daac-tools/python-daachorseExample usageDaachorse contains some search options,
ranging from basic matching with the Aho-Corasick algorithm to trickier matching.
All of them will run very fast based on the double-array data structure and
can be easily plugged into your application as shown below.Finding overlapped occurrencesTo search for all occurrences of registered patterns
that allow for positional overlap in the input text,
usefind_overlapping(). When you instantiate a new automaton,
unique identifiers are assigned to each pattern in the input order.
The match result has the character positions of the occurrence and its identifier.>>importdaachorse>>patterns=['bcd','ab','a']>>pma=daachorse.Automaton(patterns)>>pma.find_overlapping('abcd')[(0,1,2),(0,2,1),(1,4,0)]Finding non-overlapped occurrences with standard matchingIf you do not want to allow positional overlap, usefind()instead.
It performs the search on the Aho-Corasick automaton
and reports patterns first found in each iteration.>>importdaachorse>>patterns=['bcd','ab','a']>>pma=daachorse.Automaton(patterns)>>pma.find('abcd')[(0,1,2),(1,4,0)]Finding non-overlapped occurrences with longest matchingIf you want to search for the longest pattern without positional overlap in each iteration,
useMATCH_KIND_LEFTMOST_LONGESTin the construction.>>importdaachorse>>patterns=['ab','a','abcd']>>pma=daachorse.Automaton(patterns,daachorse.MATCH_KIND_LEFTMOST_LONGEST)>>pma.find('abcd')[(0,4,2)]Finding non-overlapped occurrences with leftmost-first matchingIf you want to find the the earliest registered pattern
among ones starting from the search position,
useMATCH_KIND_LEFTMOST_FIRST.This is so-calledthe leftmost first match, a bit tricky search option.
For example, in the following code,abis reported because it is the earliest registered one.>>importdaachorse>>patterns=['ab','a','abcd']>>pma=daachorse.Automaton(patterns,daachorse.MATCH_KIND_LEFTMOST_FIRST)>>pma.find('abcd')[(0,2,0)]LicenseLicensed under either ofApache License, Version 2.0
(LICENSE-APACHEorhttp://www.apache.org/licenses/LICENSE-2.0)MIT license
(LICENSE-MITorhttp://opensource.org/licenses/MIT)at your option.
Package: daacla
daaclaPython module to managementdataclassobjects using SQLiteUsagefrom dataclasses import dataclass
from datetime import datetime

from daacla import Daacla, table


@dataclass
@table(key='url')  # `key` means primary key
class Post:  # makes `Post` table on the `db` database
    url: str
    created_at: float


db = Daacla()

# Update/Insert a record
db.upsert(Post(url='https://example.com/page/1', created_at=datetime.now().timestamp()))

# Check existence of the record
print( db.exists(Post, key='https://example.com/page/1') )  # → True

# Check existence of the record
print( db.exists(Post, key='https://example.com/page/NOTHING') )  # → False

# Search
url = 'https://example.com/page/1'
for post in db.select(Post, 'url = ?', url):
  print(post.url)  # → https://example.com/page/1
Package: daak
daakIn the Tausug language, daak means to command or order.  daak is a small pure python library that can execute a
subprocess and grab the stdout and stderr asynchronously.It has limited support for handling input, mostly for when a sudo password is expected.InstallationThrough pippipinstalldaakUsageThe main class to use is calledRunimportasynciofromdaak.processimportRundefwhich(prog:str):returnRun("which",args=[prog]).run(throw=False)asyncdefmain():_,process=awaitwhich("poetry")print(process.returncode)if__name__=="__main__":withasyncio.Runner()asrunner:runner.run(main())
Package: daal4py
daal4py - A Convenient Python API to the Intel(R) oneAPI Data Analytics LibraryA simplified API to Intel(R) oneAPI Data Analytics Library that allows for fast usage of the framework suited for Data Scientists or Machine Learning users.  Built to help provide an abstraction to Intel(R) oneAPI Data Analytics Library for either direct usage or integration into one's own framework.👀 Follow us on MediumWe publish blogs on Medium, sofollow usto learn tips and tricks for more efficient data analysis the help of daal4py. Here are our latest blogs:From Hours to Minutes: 600x Faster SVMImprove the Performance of XGBoost and LightGBM InferenceAccelerate Kaggle Challenges Using Intel AI Analytics ToolkitAccelerate Your scikit-learn ApplicationsAccelerate Linear Models for Machine LearningAccelerate K-Means Clustering🔗 Important linksDocumentationscikit-learn API and patchingBuilding from SourcesAbout Intel(R) oneAPI Data Analytics Library💬 SupportReport issues, ask questions, and provide suggestions using:GitHub IssuesGitHub DiscussionsForumYou may reach out to project maintainers privately atonedal.maintainers@intel.com🛠 Installationdaal4py is available at thePython Package Index,
on Anaconda Cloud inConda-Forge channeland inIntel channel.# PyPI (recommended by default)pipinstalldaal4py# Anaconda Cloud from Conda-Forge channel (recommended for conda users by default)condainstalldaal4py-cconda-forge# Anaconda Cloud from Intel channel (recommended for Intel® Distribution for Python users)condainstalldaal4py-cintel[Click to expand] ℹ️ Supported configurations📦 PyPi channelOS / Python versionPython 3.6Python 3.7Python 3.8Python 3.9Linux[CPU, GPU][CPU, GPU][CPU, GPU][CPU, GPU]Windows[CPU, GPU][CPU, GPU][CPU, GPU][CPU, GPU]OsX[CPU][CPU][CPU][CPU]📦 Anaconda Cloud: Conda-Forge channelOS / Python versionPython 3.6Python 3.7Python 3.8Python 3.9Linux[CPU][CPU][CPU][CPU]Windows[CPU][CPU][CPU][CPU]OsX❌❌❌❌📦 Anaconda Cloud: Intel channelOS / Python versionPython 3.6Python 3.7Python 3.8Python 3.9Linux❌[CPU, GPU]❌❌Windows❌[CPU, GPU]❌❌OsX❌[CPU]❌❌You canbuild daal4py from sourcesas well.⚠️ Scikit-learn patchingScikit-learn patching functionality in daal4py was deprecated and moved to a separate package -Intel(R) Extension for Scikit-learn*. All future updates for the patching will be available in Intel(R) Extension for Scikit-learn only. Please use the package instead of daal4py for the Scikit-learn acceleration.
Package: daami-cli
daami-cliCli for daamireview.comRequirementTo run the command will need to have a google APi Key. Contact the slack channel for the key.
For initial setup you will require an API key and project directory of daamireview.InstallationFor installation (Use virtualenv if possible)virtualenv setupvirtualenvdaamisourcedaami/bin/activate# for windows.\daami\bin\activate.ps1then install the packagepipinstalldaami-cliUsageFor first time setupdaami-clisetupProject:(provideyourdaamireviewfolderpath)Apikey:(theapikey)Tmdbkey:(thetmdbkey)Author:(yourauthorname)Once done use review to create the review in _posts folderdaami-clireview
Title:(articletitle)Movie:(movienamebeingreviewed)Language:(thelanguagethemovieisin)Rating:(afloatingnum)To delete the posts use delete functiondaami-clidelete-mbalidaan# delete with datedaami-clidelete-d6/20/20# delete with since this will delete all files after a datedaami-clidelete-s5/18/20
Package: daas
DaaS中文版READMEIntroductionMesh is a standard implementation forPrivate Transmission Protocolspecification.Mesh Python develop kits base on Python3.6. Recommend usepoetryto manage
dependencies.FeaturesAs an open source Internet of Data infrastructure develop kits, Mesh has the following core functions:Minimal kernel with SPI plugin architecture, everything is replacement.Support full stack of service mesh architecture.Support full stack of service oriented architecture.Support transport with TCP, HTTP, or other RPC protocols.Support rich routing features.Support reliable upstream management and load balancing capabilities.Support network and protocol layer observability.Support mTLS and protocols on TLS.Support rich extension mechanism to provide highly customizable expansion capabilities.Support process smooth upgrade.Get StartedpoetryaddimeshorpipinstallimeshRPCDeclared rpc interface Facade.fromabcimportABC,abstractmethodfrommeshimportspi,mpi@spi("mesh")classTokenizer(ABC):@abstractmethod@mpi("mesh.trust.apply")defapply(self,kind:str,duration:int)->str:"""Apply a node token.:param kind::param duration::return:"""pass@abstractmethod@mpi("mesh.trust.verify")defverify(self,token:str)->bool:"""Verify some token verifiable.:param token::return:"""passDeclared rpc service Implement.frommeshimportmps,Tokenizer@mpsclassMeshTokenizer(Tokenizer):defapply(self,kind:str,duration:int)->str:return"foo"defverify(self,token:str)->bool:returnTrueRemote reference procedure call.frommeshimportmpi,TokenizerclassComponent:@mpideftokenizer(self)->Tokenizer:passdefinvoke(self)->bool:token=self.tokenizer().apply('PERMIT',1000*60*5)returnself.tokenizer().verify(token)TransportTransport is a full duplex communication stream implement.importmeshfrommeshimportMesh,log,ServiceLoader,Transport,Routablefrommesh.prsimimportMetadatadefmain():mesh.start()transport=Routable.of(ServiceLoader.load(Transport).get("mesh"))session=transport.with_address("10.99.1.33:570").local().open('session_id_008',{Metadata.MESH_VERSION.key():'',Metadata.MESH_TECH_PROVIDER_CODE.key():'LX',Metadata.MESH_TRACE_ID.key():Mesh.context().get_trace_id(),Metadata.MESH_TOKEN.key():'x',Metadata.MESH_SESSION_ID.key():'session_id_008',Metadata.MESH_TARGET_INST_ID.key():'JG0100000100000000',})forindexinrange(100):inbound=f"节点4发送给节点5报文{index}"log.info(f"节点4发送:{inbound}")session.push(inbound.encode('utf-8'),{},"topic")outbound=session.pop(10000,"topic")ifoutbound:log.info(f"节点4接收:{outbound.decode('utf-8')}")
Package: daawoud
Developed by Ahmed HamdiExample:Colors available: RED, GREEN, WHITE, BLACK, BROWN, CYAN, AQUA, YELLOW, BLUE, PINK, PURPLE, ORANGE, DARKRED, DARKGREEN, DARKBLUE, DARKYELLOWimport daawoud
from daawoud import Alwan, center_text

print(f'{Alwan.purple()} this is purple color!')

#centering text
print(center_text(f'this is center text'))Colorings Usage:You have to use
Alwan.thecolor()Centering Text:add center_text before the ())
Package: daba
daba by KlivolksThedabalibrary, developed by Klivolks, is a Python package designed to simplify the process of interacting with MongoDB databases. It provides convenient and easy-to-use methods for carrying out common database operations such as querying, inserting, updating, and deleting data.InstallationThis package can be installed using pip:pipinstalldabaEnvironment VariablesTwo environment variables need to be set:MONGO_URL: This is the URL of the MongoDB server.MONGO_DB: This is the name of the MongoDB database to interact with.And optional variables areMONGO_POOL_SIZE: This is the default pool size of the MongoDB database.These can be set in an.envfile that can be loaded withpython-dotenv. Remember not to commit sensitive data (like your database URLs) to version control!Example usageIn this example, thecollectionclass from thedaba.Mongomodule is being used to interact with a MongoDB collection.You can create a collection object using thecollectionmethod:db_obj=collection('test')Thecollectionobject has several methods to interact with the MongoDB collection.MethodsBelow are the methods available in thedabalibrary'scollectionclass, along with brief descriptions of what they do:init_db(): Initializes the MongoDB database.close_db(): Closes the MongoDB database connection.get(query): Returns documents that match the query.put(data): Inserts a single document into the collection.putMany(data): Inserts multiple documents into the collection.set(query, new_data): Updates a single document that matches the query.inc(query, data_to_increment): Increments the value of specific fields in a document that matches the query.setMany(query, new_data): Updates multiple documents that match the query.getOne(query): Returns a single document that matches the query.getAfterCount(query, field): Returns a document after incrementing the value of a specific field.deleteOne(query): Deletes a single document that matches the query.deleteMany(query): Deletes multiple documents that match the query.removeElement(query, element): Removes an element from an array in the documents that match the query.count(query): Counts the documents that match the query.Running TestsThis library includes a suite of unit tests. To run the tests, execute the script with a Python interpreter. Ensure the.envfile is in the same directory as the script.pythontest_daba.pyNoteThis README is not exhaustive, and is intended to be a brief introduction to the functionality provided by thedabalibrary. For a full list of functionality and options, please refer to the official documentation.
Package: dabbiew
A curses-based DataFrame viewer inspired by TabViewAboutThis is a side project for now. I work on it because I want more green squares
on my GitHub profile.The main difference between TabView and DabBiew is that underlying data
structure is a pandas DataFrame instead of a list of lists. This has the
advantage of potentially being able to take advantage of Dask, which supports
“Big Data” collections for distributed environments.Installationpip install dabbiewUsageOpen any csv or Excel file:dabbiew file.csv
dabbiew file.xlsxKey BindingsA move command can be repeated by typing the number of times to repeat before
issuing an action. For example, to move down 12 times, simply type12j(or12↓). To perform a search, open the search bar with\, enter a
substring to match, and hit return (↵).KeyActionvtoggle selection modeesccancel selectionhjkl←↓↑→movement keysctrl+f,ctrl+bpage down, page ups,Ssort ascending, descendinggg,GGjump to top, bottom of DataFrame^,$jump to left, right of DataFrame,,.decrease, increase selection width<,>decrease, increase all widthst,ytoggle header, index[,]decrease, increase index width:toggle command mode/toggle search barn,pnext, previous matchdenter ipdb debug modeqquitCommand ModeEntering command mode (:) allows the user to callany DataFrame method
which returns a Series or DataFrameon the current selection. For instance, the
user can call:sum(),:where(df==42), or even:where(df==42).sum()on a selection. The resulting Series or DataFrame is rendered in a nested
instance. To go back to the previous DataFrame, simply quit (q) the current
instance. If the selection is just a single cell, the call is made to the entire
DataFrame inplace. Note the name of the current DataFrame is always calleddf.DocumentationTo generate the source code documentation do:cd doc
make htmland open_build/html/index.html
Package: dabest
Estimation statistics is a simple framework <https://thenewstatistics.com/itns/>
that—while avoiding the pitfalls of significance testing—uses familiar statistical
concepts: means, mean differences, and error bars. More importantly, it focuses on
the effect size of one’s experiment/intervention, as opposed to
significance testing.An estimation plot has two key features. Firstly, it presents all
datapoints as a swarmplot, which orders each point to display the
underlying distribution. Secondly, an estimation plot presents the
effect size as a bootstrap 95% confidence interval on a separate but
aligned axes.Please cite this work as:
Moving beyond P values: Everyday data analysis with estimation plots
Joses Ho, Tayfun Tumkaya, Sameer Aryal, Hyungwon Choi, Adam Claridge-Changhttps://doi.org/10.1101/377978
Package: dabl
dablThe data analysis baseline library."Mr Sanchez, are you a data scientist?""I dabl, Mr president."Find more information on thewebsite.Try it outpip install dablorCurrent scope and upcoming featuresThis library is very much still under development. Current code focuses mostly on exploratory visualization and preprocessing.
There are also drop-in replacements for GridSearchCV and RandomizedSearchCV using successive halfing.
There are preliminary portfolios in the style ofPOSH
auto-sklearnto find strong models quickly.  In essence that boils down to a quick search
over different gradient boosting models and other tree ensembles and
potentially kernel methods.Check out thethe websiteandexample galleryto get an idea of the visualizations that are available.Stay Tuned!Related packagesLuxLuxis an awesome project for easy interactive visualization of pandas dataframes within notebooks.Pandas ProfilingPandas Profilingcan
provide a thorough summary of the data in only a single line of code. Using theProfileReport()method, you are able to access a HTML report of your data
that can help you find correlations and identify missing data.dablfocuses less on statistical measures of individual columns, and more on
providing a quick overview via visualizations, as well as convienient
preprocessing and model search for machine learning.
Package: daboi
Daboi PackageThis is an instagram automation with selenium.PrerequisitiesseleniumchromedriverFeaturesLikes - home feed and hashtagsFollows - hashtagsUnfollowsWatch storiesInstallpip3installdaboiUpdatepip3install-UdaboiRunfromdaboiimportinstabotconfig={"user":"username","password":"password"i,#"chromedriver_path":"", # path to chromedriver default is linux /usr/lib/chromium-browser/chromedriver#"path":"" # where the output files will be stored default is working directory"hashtag_list":["hashtag1","hashtag2"],#hashtags to give likes to photos"likes":15,#likes per run to give"follow":0,#follow profiles per run"unfollow":0,#unfollow profiles per run"follow_profiles":["username1","username2"],#follow the followers of given profiles"wait_between_runs":2,#wait between two consecutive runs"watch_stories_minutes":5,#watch hasthags and progile stories in minutes"give_likes_when":0,#photo has to have also another one or more hashtags set in hashtag_list"api_key":"",# api token to authentificate"api_endpoint"=""# url where to send run statistics. you might need to change code for your own needs but you might want to implement two methods get and write}instabot.Client(config)#enjoy the stonks
Package: dac
dac: Data as CodeData-as-Code (DaC)dacis a tool that supports the distribution of data as (python) code.IMPORTANT: Currently the project is in the initial development phase, this is why releases are marked as0.z.y.
(followingsemantic versioning 2.0.0: "Major version zero (0.y.z) is for initial development.
Anything MAY change at any time. The public API SHOULD NOT be considered stable.").
While in this phase, we will denote breaking changes with a minor increase.📔User documentationSetup development environment (for contributors only)Create a virtual environment and activate itpython-mvenvvenv
.venv/bin/activateInstall the developer dependenciespython-mpipinstall-Upipwheelsetuptools
python-mpipinstall-rrequirements-dev.txtEnable the pre-commitspre-commitinstallTo run all the testspytest--run-slow(omit--run-slowto run only the fast unit tests)
Package: dacareux-httpbin
version 0.0.0Dacareux’s python client to httpbin.org, open sourced under the MIT licenseInstallpipinstalldacareux-httpbinDocumentationhttps://dacareux-httpbin.readthedocs.orgBasic Usage# demo usage for your python packagethisisanopportunitytogettheattentionofpotentialusersofyourpackage/tool/libraryContributingCheck thecode structure documentationWrite testsWrite codeSend a pull-request
Package: dac-autoreg
AboutThis module is used to registerendpointsandservice namestoDAC[Dyncamic Access Control] service.DAC[Dyncamic Access Control] service is used to control accesses betweenmicroservicesandusersVisithttps://github.com/OnePoint-Team/DACfor more information aboutDACservice🔨  Installation$sudopip3installdac_autoreg🕹 Python ModulefromfastapiimportFastAPIfromcore.factoriesimportsettingsfromcore.extensionsimportlogfromdac_autoreg.modulesimportAutoregapp=FastAPI()@app.on_event("startup")asyncdefstartup():awaitAutoreg(app=app,log=log,settings=settings).autoreg()Supported OSLinux, MacOS🌱 ContributingFeel free to open issue and send pull request.Python >= 3.6
Package: dace
aCe - Data-Centric Parallel ProgrammingDecoupling domain science from performance optimization.DaCe is afastparallel programming
framework that takes code in Python/NumPy and other programming languages, and maps it to high-performanceCPU, GPU, and FPGAprograms, which can be optimized to achieve state-of-the-art. Internally, DaCe
uses the Stateful DataFlow multiGraph (SDFG)data-centric intermediate
representation: A transformable, interactive representation of code based on
data movement.
Since the input code and the SDFG are separate, it is possible to optimize a
program without changing its source, so that it stays readable. On the other
hand, transformations are customizable and user-extensible, so they can be written
once and reused in many applications.
With data-centric parallel programming, we enabledirect knowledge transferof performance optimization, regardless of the application or the target processor.DaCe generates high-performance programs for:Multi-core CPUs (tested on Intel, IBM POWER9, and ARM with SVE)NVIDIA GPUs and AMD GPUs (with HIP)Xilinx and Intel FPGAsDaCe can be written inline in Python and transformed in the command-line/Jupyter
Notebooks or SDFGs can be interactively modified using ourVisual Studio Code extension.For more information, see the documentationQuick StartInstall DaCe with pip:pip install daceHaving issues? See our fullInstallation and Troubleshooting Guide.Using DaCe in Python is as simple as adding a@dacedecorator:importdaceimportnumpyasnp@dacedefmyprogram(a):foriinrange(a.shape[0]):a[i]+=ireturnnp.sum(a)Callingmyprogramwith any NumPy array or GPU array (e.g., PyTorch, Numba, CuPy) will
generate data-centric code, compile, and run it. From here on out, you canoptimize(interactively or automatically),instrument, anddistributeyour code. The code creates a shared library (DLL/SO file) that can readily
be used in any C ABI compatible language (C/C++, FORTRAN, etc.).For more information on how to use DaCe, see thesamplesor tutorials below:Getting StartedBenchmarks, Instrumentation, and Performance Comparison with Other Python CompilersExplicit Dataflow in PythonNumPy API ReferenceSDFG APIUsing and Creating TransformationsExtending the Code GeneratorPublicationThe paper for the SDFG IR can be foundhere.
Other DaCe-related publications are available on ourwebsite.If you use DaCe, cite us:@inproceedings{dace,author={Ben-Nun, Tal and de~Fine~Licht, Johannes and Ziogas, Alexandros Nikolaos and Schneider, Timo and Hoefler, Torsten},title={Stateful Dataflow Multigraphs: A Data-Centric Model for Performance Portability on Heterogeneous Architectures},year={2019},booktitle={Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis},series={SC '19}}ContributingDaCe is an open-source project. We are happy to accept Pull Requests with your contributions! Please follow thecontribution guidelinesbefore submitting a pull request.LicenseDaCe is published under the New BSD license, seeLICENSE.