Saravanan666/pypi-org huggingface dataset:
Package: preln
A package for preprocessing text in spanishPreln is a Python package that speeds up development and optimizes the performance of applications that require adequate data processing in the field of NLP (Natural Language Processing). This library takes into account the special characteristics of data written in Spanish. It makes data suitable and ready to use for complex applications like training machine-learning models, extracting content from social media or develop powerful tools to automate language correction, lemmatization, stemming within manny others.📃​Last version v0.5.1-alpha out now!📃​💬​ Contribution & QuestionsContribution & Questions TypePlatforms🐞​​Bug Reports[GitHub Issue Tracker]📦​Feature Requests & Ideas[GitHub Discussions]🛠️​Usage Questions & Discusions[GitHub Discussions]💼​ FeaturesApply and combine general basic operations to pre-process text in SpanishEstablish direct connection with file paths, databases… for easy reading and writing dataSimple implementation, optimized and ready to apply configuration filesAutocorrect function to improve data qualityMethods for privacy control, replacing or removing personal data from the datasetSupport for spanish and english languages​💾​ Install PrelnTo start using Preln use the next command:pip install prelnNote: you might have to add this command as a “code” line in order to use Preln on a Python notebook.If you are using an old version of Preln, check the update guide to install the package’s new changes.The main object class of the package is calledPreprocessingand it contains all the principal functions of the package. We will be importing this class and creating and object in order to use it’s methods:fromPreln.preprocessingimportPreprocessingpreprocessor=Preprocessing(date=False,date_format=None,accents=False,lowercasing=True,privacy=True,privacy_format="multi:replace",correction=True,media=True,media_format="mention:delete",numbers=False,punctuation=True,stopwords=True,tokenizer=True,debug=False)🔧​ Example of useIn this basic example, you can check how to use the package in order to process a simple piece of text.sample_text="¡Hola @usuario!, mi nombre es Preln, me han creado Adrián y Raúl. Revisa mi documentación en https://www.preln.org"test=preprocessor.pipeline(sample_text)print(test)# ['MENTION', 'nombre', 'ORG', 'creado', 'PERSON', 'PERSON', 'revisa', 'documentación', 'URL']Note: The pipeline method has it´s parameters (which toggle the core methods) setted by default. It’s interesting to change them based on each text we want to process.You can check every option upon the core methods and find out what combination of them suits perfectly with your dataset💳​ LicensePreln is licensed underMIT License.🗃️ Shields
Package: preload
PreloadPython programs often seem to "hang" in the beginning. This is due to
heavy modules being imported. This package lets the user know what is
happening, to avoid this impression:Installationpip install preloadThis will get you theUsagefrompreloadimportpreloadpreload(["matplotlib.pyplot","scipy.signal"])# Rest of your imports and code, such as:importnumpyasnpimportscipy.signalimportmatplotlib.pyplotaspltprint("Hello")
Package: preloader
Website SiteMap Preloader :rocket:Package for preloading website URLS from a provided SITEMAP URL.
You can use this package to preload your website URLS in the background, so that your website will be faster for your users.
You can set the depth in case It has more than one level.Requirements :clipboard:Python 3.6+Installation :wrench:Use the package managerpipto install preloader.pip install .How to use :question:Follow the steps below to use the package on a python project.from preloader import Preloader
    sitemap_url = 'https://www.example.com/sitemap.xml'
    preloader = Preloader(sitemap_url, depth=2)

    preloader.fetch_pages()Testing :white_check_mark:We use pytest for testing. To run the tests, run the following command in the root directory of the project.pytest -sContributing :handshake:Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
Package: preloop-cli
Preloop CLIUsing this command line tool is the quickest way to interact with your Preloop entities.Installation instructionsUse pip to install the CLI. It's recommended to do so in a virtual environment.pip install preloop-cliAuthenticationUse environment variables to store an API key generated in your account to authenticate with Preloop.export PRELOOP_KEY_ID=<key_id>
export PRELOOP_SECRET=<secret>CommandsStart withpreloop --helpto display a list of commands. You can also use--helpalong with a command to display a list of possible arguments and options that can be used with the command.preloop list-datasources --help
Package: preloop-sdk
Preloop SDKThis package provides a SDK to interact with the Preloop API, and additionally provides the methods required to write feature scripts using the "Inception" method. Preloop is
an intelligent feature platform that helps ML and AI teams move quicker and more efficiently, while enabling them to focus more on the science and productionization of their models,
and less on the data infrastructure.Installation instructionsUse pip to install the SDK. It's recommended to do so in a virtual environment.pip install preloop-sdkAuthenticationUse environment variables to store an API key generated in your account to authenticate with Preloop.export PRELOOP_KEY_ID=<key_id>
export PRELOOP_SECRET=<secret>
Package: prelude
Prelude is a Universal “Security Information & Event Management” (SIEM) system.
Prelude collects, normalizes, sorts, aggregates, correlates and reports all
security-related events independently of the product brand or license giving
rise to such events; Prelude is “agentless”.As well as being capable of recovering any type of log (system logs, syslog,
flat files, etc.), Prelude benefits from a native support with a number of
systems dedicated to enriching information even further (snort, samhain, ossec,
auditd, etc.).Prelude standardizes all the notables or suspicious events toIDMEFstandard format (RFC 4765). With this format, events are enriched to facilitate
automation and correlation processes but also to provide as much information to
the operator (contextualization alerts) to allow it to respond quickly and
effectively.Libprelude is a collection of generic functions providing communication between
all Sensors, like IDS (Intrusion Detection System), and the Prelude Manager. It
provides a convenient interface for sending and receiving IDMEF (Information
and Event Message Exchange Format) alerts to Prelude Manager with transparent
SSL, fail-over and replication support, asynchronous events and timer
interfaces, an abstracted configuration API (hooking at the command-line, the
configuration line, or wide configuration, available from the Manager), and a
generic plugin API. It allows you to easily turn your favorite security program
into a Prelude sensor.InstallingInstall requirements to build the C part:yum group install "Development Tools"

yum install python-develInstall and update usingpip:pip install -U preludeA Simple Exampleimportpreludeif__name__=='__main__':idmef=prelude.IDMEF()idmef.set("alert.classification.text","Hello world!")print(idmef)LinksWebsite:https://www.prelude-siem.org/Documentation:https://www.prelude-siem.org/projects/prelude/wikiReleases:https://www.prelude-siem.org/projects/prelude/filesCode:https://github.com/Prelude-SIEM/libpreludeIssue tracker:https://www.prelude-siem.org/projects/prelude/issuesOfficial chat:irc://#prelude@irc.freenode.net
Package: prelude-cli
Prelude CLIInteract with the full range of features in Prelude Detect, organized by:IAM: manage your accountBuild: write and maintain your collection of security testsDetect: schedule security tests for your endpointsQuick startpipinstallprelude-cli
prelude--help
prelude--interactiveDocumentationhttps://docs.preludesecurity.com/docs/prelude-cli
Package: prelude-parser
Prelude ParserParses XML files exported fromPrelude EDCinto formats Python can use.Installationpipinstallprelude-parserOptionally thepandasextra can be installed to parse to a PandasDataFrameNote: Pandas only supports Python 3.9+ so this is not available in Python 3.8.pipinstallprelude-parser[pandas]Optionally thepolarsextra can be installed to parse to a PolarsDataFramepipinstallprelude-parser[polars]All extras can be install withpipinstallprelude-parser[all]UsageParse a Prelude flat XML file to a Python dictionary.fromprelude_parserimportparse_to_dictdata=parse_to_dict("physical_examination.xml")Parse a Prelude flat XML file into a list of Python class. The name of the class is taken from the
form name node in the XML file converted to pascal case. For example a <physical_examination> node
will result in a PhysicalExamination class being created.fromprelude_parserimportparse_to_classesdata=parse_to_classes("physical_examination.xml")Parse a Prelude flat XML file into a Pandas DataFrame. This works for Prelude flat XML files that
were exported with the "write tables to seperate files" option. In order to use this optionprelude-parsereither needs to be installed with thepandasextra or theallextras.fromprelude_parser.pandasimportto_dataframedf=to_dataframe("physical_examination.xml")Parse a Prelude flat XML file into a Polars DataFrame. This works for Prelude flat XML files that
were exported with the "write tables to seperate files" option. In order to use this optionprelude-parsereither needs to be installed with thepolarsextra or theallextras.fromprelude_parser.polarsimportto_dataframedf=to_dataframe("physical_examination.xml")ContributingContributions to this project are welcome. If you are interesting in contributing please see ourcontributing guide
Package: prelude-sdk
Prelude SDKInteract with the Prelude Service API via Python.The prelude-cli utility wraps around this SDK to provide a rich command line experience.Install this package to write your own tooling that works with Build or Detect functionality.IAM: manage your accountBuild: write and maintain your collection of security testsDetect: schedule security tests for your endpointsQuick startpipinstallprelude-sdkDocumentationTBDTestingTo test the Python SDK and Probes, run the following commands from the python/sdk/ directory:pipinstall-rtests/requirements.txt
pytesttests--apihttps://api.preludesecurity.com--email<EMAIL>
Package: premai
Prem Python SDKInstallationYou can install the Prem Python SDK directly from PyPI.pipinstallpremaiUsageGetting StartedTo use the Prem Python SDK, you need to obtain an API key from the Prem platform. You can then create aPreminstance to make requests to the API.frompremaiimportPremclient=Prem(api_key=YOUR_API_KEY)Chat completionThechat.completionsmodule allows you to generate completions based on user input. Here's an example:messages=[{"role":"user","content":"Who won the world series in 2020?"},]model="gpt-3.5-turbo"# optionalsystem_prompt="You are a helpful assistant."# optionalsession_id="my-session"# optional: a unique identifier to maintain session context, useful for tracking conversations or data across multiple requestsproject_id=PROJECT_ID# Create completionresponse=client.chat.completions.create(project_id=project_id,messages=messages,model=model,session_id=session_id,system_prompt=system_prompt,stream=False)print(response.choices)# Create completion with streamresponse=client.chat.completions.create(project_id=project_id,messages=messages,model=model,session_id=session_id,system_prompt=system_prompt,stream=True)forchunkinresponse:ifchunk.choices[0].delta["content"]:print(chunk.choices[0].delta["content"],end="")print(f"\nTrace ID:{response.trace_id}")
Package: premailer_cspw
Turns CSS blocks into style attributesWhen you send HTML emails you can’t used style tags but instead you
have to put inlinestyleattributes on every element. So from this:<html>
<style type="text/css">
h1 { border:1px solid black }
p { color:red;}
</style>
<h1 style="font-weight:bolder">Peter</h1>
<p>Hej</p>
</html>You want this:<html>
<h1 style="font-weight:bolder; border:1px solid black">Peter</h1>
<p style="color:red">Hej</p>
</html>premailer does this. It parses an HTML page, looks upstyleblocks
and parses the CSS. It then uses thelxml.htmlparser to modify the
DOM tree of the page accordingly.Getting startedIf you havena’t already done so, installpremailerfirst:$ pip install premailerNext, the most basic use is to use the shortcut function, like this:>>> from premailer import transform
>>> print transform("""
...         <html>
...         <style type="text/css">
...         h1 { border:1px solid black }
...         p { color:red;}
...         p::first-letter { float:left; }
...         </style>
...         <h1 style="font-weight:bolder">Peter</h1>
...         <p>Hej</p>
...         </html>
... """)
<html>
<head></head>
<body>
<h1 style="font-weight:bolder; border:1px solid black">Peter</h1>
        <p style="color:red">Hej</p>
        </body>
</html>For more advanced options, check out the code of thePremailerclass
and all its options in its constructor.Turning relative URLs into absolute URLsAnother thing premailer can do for you is to turn relative URLs (e.g.
“/some/page.html” into “http://www.peterbe.com/some/page.html”). It
does this to allhrefandsrcattributes that don’t have a://part in it. For example, turning this:<html>
<body>
<a href="/">Home</a>
<a href="page.html">Page</a>
<a href="http://crosstips.org">External</a>
<img src="/folder/">Folder</a>
</body>
</html>Into this:<html>
<body>
<a href="http://www.peterbe.com/">Home</a>
<a href="http://www.peterbe.com/page.html">Page</a>
<a href="http://crosstips.org">External</a>
<img src="http://www.peterbe.com/folder/">Folder</a>
</body>
</html>by usingtransform(’…’, base_url=’http://www.peterbe.com/’).HTML attributes created additionallyCertain HTML attributes are also created on the HTML if the CSS
contains any ones that are easily translated into HTML attributes. For
example, if you have this CSS:td { background-color:#eee; }then
this is transformed intostyle=”background-color:#eee”AND as an
HTML attributebgcolor=”#eee”.Having these extra attributes basically as a “back up” for really shit
email clients that can’t even take the style attributes. A lot of
professional HTML newsletters such as Amazon’s use this.
Package: premaseemutils
Utils package by Premaseemcommendations for version control, documentation, or testing.[The source for this project is available here][https://github.com/premaseem/premaseem-pyutils].Most of the configuration for a Python project is done in thesetup.pyfile,
an example of which is included in this project. You should edit this file
accordingly to adapt this sample project to your needs.installationpip install premaseemutilsusagefrom calculator.square import *
get_square(4)
16Build distributionpython setup.py bdist_wheel
or
python setup.py sdistpushing distributionpip install twine
twine upload dist/*install locallypip install dist/premaseemutils-2.0.0-py3-none-any.whlinstalling locally
Package: premise-gwp
premise_gwpImport the official IPCC's GWP20a/GWP100a characterization factors into Brightway2, with the addition of
hydrogen and biogenic CO2uptake and release flows. This is needed when usingpremise-generated LCI databases for two reasons:in some scenarios, hydrogen-based supply chains (and associated losses) are significantsome scenarios rely on Bioenergy with carbon capture and storage (BECCS), Direct Air capture (DAC),
and any other forms of storage using biomass or atmospheric resources.
Without it, negative emission technologies (NET) do not yield a net negative
carbon footprint.Impact categoryThis adds:IPCC 2013 and 2021, climate change, GWP 100a, with hydrogen"Hydrogen", with a CF of 33 and 11 for GWP20 and GWP100 respectively.IPCC 2013 and 2021, climate change, GWP 100a, with hydrogen and bio CO2"Hydrogen", with a CF of 33 and 11 for GWP20 and GWP100 respectively."Carbon dioxide, in air", with a CF of -1"Carbon dioxide, non-fossil, resource correction", with a CF of -1"Carbon dioxide, non-fossil", with a CF of +1The biogenic carbon balance in the rest of the ecoinvent database should be correct.
Hence, using this method, instead of the regular IPCC GWP method, should not
yield any difference, as long as BECCS are not present and solicited in the database.The characterization factors for the global warming impact GWP100a of for hydrogen
is taken fromWarwick et al, 2022.LimitationNow works withbw2io 0.8.7andbw2io 0.8.8.
Ifbw2io 0.8.8is present, IPCC 2021 methods will be
installed, otherwise IPCC 2013 methods will be installed.UsageIn an open Brightway2 project:frompremise_gwpimportadd_premise_gwpadd_premise_gwp()Installationpip install premise_gwporconda install -c romainsacchi premise_gwp
Package: premium-bonds-prize-checker
Premium Bonds Prize CheckerA simple CLI tool to check whether you have won anything for the current month in the UK's Premium Bonds.InstallThe recommended way to install is to usepipx:pipx install premium-bonds-prize-checkerUsagepremium-bonds-prize-checker [holders_numbers]Multiple holders numbers can be checked by specifying them with commas, e.g.123456,987654.If the holders number is omitted then a config will be loaded from~/.config/premium-bonds/config.jsonwhich has the format:{"comment or name": "<holders-number>"}
Package: premium-primitives
Premium PrimitivesPremium Primitives is a package to use withFeaturetoolsthat provides additional primitives for feature generation.python-mpipinstallfeaturetools[premium]SupportThe Featuretools community is happy to provide support to users of Featuretools. Project support can be found in four places depending on the type of question:For usage questions, useStack Overflowwith thefeaturetoolstag.For bugs, issues, or feature requests start aGithub issue.For discussion regarding development on the core library, useSlack.For everything else, the core developers can be reached by email atopen_source_support@alteryx.comBuilt at AlteryxFeaturetoolsis an open source project maintained byAlteryx. To see the other open source projects we’re working on visitAlteryx Open Source. If building impactful data science pipelines is important to you or your business, please get in touch.
Package: premodel
K-Nearest Neighbourspredict: Returns the predicted valuevisualize: Returns  a matplotlib scatter plot of the data along with the predicted point and its value. (Requires the calling of predict() method first)euclidean: Returns the Euclidean distance of the given point from all the points given in the datasetLinear Regressionfit: Trains the model to the given data and return the slope and intercept valuespredict: Returns the predicted value
Package: premsai-pypi-premsaisahoo
premsai_pypiURL(official python docs)[https://packaging.python.org/en/latest/tutorials/packaging-projects/]URL(github docs)[https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries]how to use this packagefromoneNeuron.perceptronimportPerceptronmodel=Perceptron(eta=ETA,epochs=EPOCHS)model.fit(X,y)
Package: prem-utils
🛠️ Prem UtilsUtilities, and Connectors in order to interact with all Model Serving and Fine-tuning Providers.🤙 Usagepipinstallprem-utilsfromprem_utils.connectorsimportopenaiconnector=openai.OpenAIConnector(api_key="")prompt="Hello, how are you?"response=connector.chat_completion(model="gpt-3.5-turbo",messages=[{"role":"user","content":prompt}])message=response["choices"][0]["message"]["content"]print(message)📦 ContributeInstall the necessary dependenciesvirtualenvvenv-p=3.11sourcevenv/bin/activate
pipinstall-rrequirements.txtTest all or one connector# will run all the connectorspythone2e.py# only one connectorpythone2e.py--nameperplexity
Package: prenacs
PrenacsPrenacs is a system, which allows to run batch computations of attribute
values for sets of entities, and to store the computation results in a
database, alongside metadata which allows to track the data provenance.The name is an acronym for
"PRovenance-tracking ENtity Attribute Computation and Storage system".Key conceptsEntitiesare thereby object of any kind, characterized by an identifier,
which allows distinguishing the object from other objects of the same kind.
For each entity, ProBatch allows to compute the values of attributes.Attributeare properties of the entity. Anything whose value can be
determined using a computation (in a general sense, thus e.g. also obtaining
the value from an external data source) is an attribute. Each attribute may
consist of a single value (scalar attribute) or or multiple values
(composite attribute). The attribute system is open and flexible, i.e. new
attributes can be added at any moment.ProvBatch allows to store asingle instanceof each attribute for an entity:
that is, it is not meant to store multiple measurements of a value or
to store a journal of previous attribute computation results.Alongside the computation results, ProBatch allows to track theprovenanceof
attribute values. For achieving this, the code for attribute value computation
must be implemented in form of acomputation plugin. Multiple plugins
may be available for computing the same attribute. A plugin may compute one
or multiple attributes. Plugins contain the code for the attribute computation,
as well as metadata, describing the input, output, supported paramaters and
methods and implementation notes. Whenever a plugin code changes, a
newplugin version numberis assigned.Batch computation metadata instances are identified by an unique identifier
(UUID) and include a reference to a given plugin (plugin identifier and version
number), alongside information such as the computation parameters, timestamps,
identifier of the user starting the computation, and key system data.
Thus, storing the batch computation UUIDs alongside with computation results,
ProvBatch allows to keep track of the data provenance.Related librariesPrenacs has been developed as part of an ecosystem of Python libraries,
including:multiplug, which implements the infrastructure for the plugin systemattrtables, which implements the infrastructure for the storage of
attribute values and metadatasnacli, which is used for implementing double-purpose scripts, callable
interactively from the command line, as well as inside a Snakemake pipelineUsageThe usage of the library is explained in theuser manual.