Saravanan666/pypi-org huggingface dataset:
Package: pycairo
Pycairo is a Python module providing bindings for thecairo graphics library. It depends oncairo >= 1.15.10and works
withPython 3.8+andPyPy3. Pycairo, including this documentation, is
licensed under theLGPL-2.1-only OR MPL-1.1.The Pycairo bindings are designed to match the cairo C API as closely as
possible, and to deviate only in cases which are clearly better implemented in
a more ‘Pythonic’ way.pipinstallpycairoInstalling Pycairo requires cairo including its headers. For more info see
“Getting Started”.importcairowithcairo.SVGSurface("example.svg",200,200)assurface:context=cairo.Context(surface)x,y,x1,y1=0.1,0.5,0.4,0.9x2,y2,x3,y3=0.6,0.1,0.9,0.5context.scale(200,200)context.set_line_width(0.04)context.move_to(x,y)context.curve_to(x1,y1,x2,y2,x3,y3)context.stroke()context.set_source_rgba(1,0.2,0.2,0.6)context.set_line_width(0.02)context.move_to(x,y)context.line_to(x1,y1)context.move_to(x2,y2)context.line_to(x3,y3)context.stroke()Features of the Pycairo bindings:Provides an object oriented interface to cairo.Queries the error status of objects and translates them to exceptions.Provides a C API that can be used by other Python extensions.Fully typed and documented API.For more information visithttps://pycairo.readthedocs.io
Package: pycaiso
pycaisopycaiso is a python wrapper for the California Independent System Operator (CAISO) Open Access Same-time Information System (OASIS) API.pycaiso currently supports the following reports and resultsets:PricesSystem DemandAtlasInstallpipinstallpycaisoExamplesGet locational marginal prices (LMPs) in Day Ahead Market (DAM) for arbitrary Node and period:
Note: "DAM" is the default market. You can also set the market parameter in get_lmps to "RTM" or "RTPD".frompycaiso.oasisimportNodefromdatetimeimportdatetimeimportpandasaspd# select pnodecj=Node("CAPTJACK_5_N003")# create dataframe with LMPS from arbitrary period (30 day maximum).cj_lmps=cj.get_lmps(datetime(2021,1,1),datetime(2021,1,2))print(cj_lmps.head())#        INTERVALSTARTTIME_GMT        INTERVALENDTIME_GMT  ...        MW  GROUP# 0  2021-01-01T08:00:00-00:00  2021-01-01T09:00:00-00:00  ...  33.32310      1# 1  2021-01-01T08:00:00-00:00  2021-01-01T09:00:00-00:00  ...   0.00000      2# 2  2021-01-01T08:00:00-00:00  2021-01-01T09:00:00-00:00  ...  34.68627      3# 3  2021-01-01T08:00:00-00:00  2021-01-01T09:00:00-00:00  ...  -1.36317      4# 4  2021-01-01T09:00:00-00:00  2021-01-01T10:00:00-00:00  ...  31.51635      1Alternatively, you can use pre-built Nodes for major aggregated pricing nodes (apnodes) like SP15:# use pre-built pnodesp15=Node.SP15()sp15_lmps=sp15.get_lmps(datetime(2021,1,1),datetime(2021,1,2))print(sp15_lmps.head())#        INTERVALSTARTTIME_GMT        INTERVALENDTIME_GMT  ...        MW  GROUP# 0  2021-01-01T08:00:00-00:00  2021-01-01T09:00:00-00:00  ...  33.48613      1# 1  2021-01-01T08:00:00-00:00  2021-01-01T09:00:00-00:00  ...   0.00000      2# 2  2021-01-01T08:00:00-00:00  2021-01-01T09:00:00-00:00  ...  34.68627      3# 3  2021-01-01T08:00:00-00:00  2021-01-01T09:00:00-00:00  ...  -1.20014      4# 4  2021-01-01T09:00:00-00:00  2021-01-01T10:00:00-00:00  ...  31.58175      1
Package: pycaixafederal
pycaixafederalAcesse seus extratos da Caixa Federal pelo PythonInstalaçãoDisponível via pippip install pycaixafederalAquisitando dadosVocê ainda precisa ter o Warsaw instalado visto que este é um web crawlerimportpycaixafederalprint(pycaixafederal.get(usuario,senha))ContribuindoEnvie sua PR para melhorar esse projeto ! 😋
Package: pyCal2PDF
READMEpyCal2PDF is inspired by python moduleCalendarwhich can generate either html or txt calendars with extra goal to generate:*.pdf Calendarfill calendar with information coming from iCalendar files (*.ics)easy configuration of different printing templatesSETUPNote only tested with python 3.9pip install pyCal2PDFPDF Calendar generationfor examples on how to generate calendar see thetestfolder.
Package: pycalbi
CALBI: Concurrent Automation Library for Bots in IntelmqDescriptionCALBI is a library designed to manage concurrent execution of the same Intelmq bot instances when dealing with rate-limited APIs or applications.FeaturesDynamic rate-limiting.Asynchronous execution of bot tasks.Configurable parameters for bot instancesRequirementsPython >= 3.6Intelmq >= 2.0RedisInstallationbash
pip install pycalbiOr from source:git clone https://github.com/CSIRTAmericas/CALBI.git
cd CALBI
python setup.py installUsefrom pycalbi.pycalbi import CalbiTake a look at boyt.py to take a look in a full bot example.ContributingPull requests are welcome. Please make sure to update tests as appropriate.Note: If you paste this into a README.md file, the nested code blocks should render correctly on GitHub.
Package: pycalc
Python libraries such as numpy, sympy, and matplotlib in combination with
IPython make for an excellent desktop calculator. Unfortunately, however,
setting up an ipython session with all the necessary imports takes quite a
while. Pycalc provides a way to quickly import all the libraries necessary for a
powerful calculator without incurring a prohibitive start up time.SetupPycaclc can be installed from pypi by issuingpip install –user pycalc.
Pycaclc does not require for all it’s dependencies to be installed though. To
get the full pycalc experience, runpip install –user -r
recommended_requirements.txt.
Package: pycalc3
CalculatorPerform basic math operations with internal memoryCalculator methods:add- add a real number to the internal memory valuesubtract- subtract a real number from the internal memory valuemultiply- multiply the internal memory value by a real numberdivide- divide the internal memory value by a real numberroot- take (n) root of the internal memory valuereset- reset the internal memory valueInstallationpipinstallpycalc3Usage>>>frompycalc3.calculatorimportCalculator>>>cal=Calculator()>>>cal.add(12)>>>cal.memory_value12.0>>>cal.subtract(3)>>>cal.memory_value9.0>>>cal.multiply(3)>>>cal.memory_value27.0>>>cal.divide(3)>>>cal.memory_value9.0>>>cal.root(2)>>>cal.memory_value3.0>>>cal.reset()>>>cal.memory_value0.0ChangelogLicenseMIT
Package: pyCalcErr
pyCalcErrcalculate Gauss propagation of uncertainty and output corresponding latex equationpropagation of uncertainty (used in this package):install using pip:pip install pyCalcErrUsage:pyCalcErr <equation left side>", "<equation_right_side> <deriveAfter_1,...>"Example:pyCalcErr E_pot 1/2*k*x**2 'x'
Package: pycalc-ffg
pycalc_ffgDescription.
The package pycalc_ffg is used to add some simple calculation features.InstallationUse the package managerpipto install pycalcpipinstallpycalc_ffgUsagefrompycalc_ffgimportbasicbasic.somar()basic.subtrair()basic.multiplicar()basic.dividir()frompycalc_ffgimportprimeprime.primos()AuthorFelipeLicenseMIT
Package: pycalci
A simple Calculator ProjectIn this project, i used aFireto solve expressions such as BODMAS,which solves multiple operations i.e addition,subtraction,multiplication and division. Wherefireis a Python library that will turn any Python component into a command line interface with just a single call to Fire.
The easiest way to useFireis to take any Python program, and then simply call fire.Fire() at the end of the program. This will expose the full contents of the program to the command line.Getting StartedHow to run project?Create a virtual environment on your local machinepython3 -m venv envActivate virtual environmentsource env/bin/activateMake a local directoryClone project in your directorygit clone https://github.com/mugdhadalal/pycalci.gitInstall setup.pypython3 setup.py installUse command pycalci,it will show you commands$ pycalci

NAME
    pycalci
SYNOPSIS
    pycalci COMMAND
COMMANDS
    COMMAND is one of the following:

     solveuse pycalci solve EXPRESSION$ pycalci solve 2+4*5/2
12.0Exampleimport fire

def hello(name):
  return 'Hello {name}!'.format(name=name)

if __name__ == '__main__':
  fire.Fire()Here's how we can run our program from the command line:$ python example.py hello World
Hello World!DependanciesScripting Language =	Python 3.0+Command-Line Option  =	fire
Package: pycalco
Calco: A Powerful Expression EvaluatorPyCalco or shortly Calco is a powerful command line interface for arithmetic and algebraic or symbolic expressions evaluation. Its power relies on themathmodule from Python standard library andSymPymodule, which is a Python library for symbolic mathematics. If you are new to SymPy or symbolic computation, start with theirtutorial, it is a great place where to start from.Why Another Python Calculator?There are so many Python calculators or expression evaluators out there for evaluating mathematical expressions; why does PyCalco exist?
Well, we acknowledge that question is legitimate, but it is easy to answer: because there is not a single command line utility for expression evaluation in Python out there which ticks the following boxes:is simple, interactive and intuitivesupports both arithemetic and algebraic expressions evaluationis highly customizable with the ability to add new scientific modules without too much strugglesuppports variable assignmentneeds no python import statements to use globally available mathematical functionscomes with useful common helpers (getting terminal dimensions, ANSI colors, fetching direct keyboard input, screen clearing, command history, various other assignment tools, supporting bang shortcuts, etc.)PyCalco actually implements its own shell and is designed to be fun and customizable but not overly flexible. To get an understanding of what PyCalco is all about, we strongly recommend looking at thePyCalco Tutorials.InstallationPyCalco is available on thePython Package Index, which makes its installation quite easy.
You just need python3 and its package manager pip3 on your plateform, then you are set to install PyCalco.Run the following command from the terminal for installation:pip install pycalcoIf that didn't work, try:python3 -m pip install pycalcoUsageAfter installation to run PyCalco interactively just type, again from the terminal, the following command:pycalco launchAnd voilà, you are ready to use PyCalco. You should see the PyCalco shell waiting for you to enter your commands and evaluate expressions. Typehelpto get help on how to use PyCalco. You can also type directly any valid arithmetic and symbolic expression to get it evaluated.DocumentationThe project documentation is located athttps://docs.trabdlkarim.com/projects/pycalco/en/latest/. Please note that the documentation is still a work in progress, so improvements to it are welcome.Support & ContributionPyCalco is under BSD 3-Clause Revised License, which means its license is anOpen Source Initiativeapproved license. Being an open source software PyCalco needs your support. Feel free to contribute to this project by forking it and submitting your changes as a pull request. Feel also free to report any bugherethat you may find. And we also welcome greatly new feature suggestions.
So please do not hesitate to send us your feedback.For more detailed informations about PyCalco visit theproject homepage.Made with :heart: and Python!!!
Package: pycalculation
pyclcA smooth, lightweight and beautiful library for global calculation and morepipinstallpyclcFeaturesPycalculation contains the following available modules:MathPhysicsGeometryGeneral(which contains overall functions and calculations used)UsagefrompyclcimportMathmath=Math()print(math.permutation(5,2))ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
Package: pycalculix
Meshing uses Calculix or GMSHWebsite:http://justinablack.com/pycalculix/Source Code:https://github.com/spacether/pycalculixDocumentation:https://pythonhosted.org/pycalculix/Useful applications of Pycalculix:Trade studies for plane stress, plane strain, or axisymmetric partsQuick Kt analysis of 2D geometryLearning finite element analyis (FEA) and PythonNotes:I build a chunker in python which tries to cut big areas (> 5 sides) which
cgx can’t mesh into smaller areas (<= 5 sides) which are meshable in cgx.
The chunker may not always be able to cut areas correctly.Elements Supported:Axisymmetric, plane stress, and plane strain elements are supported.
First and second order triangles and quadrilaterals are supported.First order elements only have corner nodesSecond order elements have corner and mid-side nodesSecond order elements produce more accurate results
Setting element divisions on lines is supportedGeometry Building:One can build separate parts made of points, lines, arcs, and areas.
One can draw a part made of straight lines, then smooth out corners by adding
blends/fillets with the part method: part.fillet_lines(L1, L2, arc_radius)
The new fillet will be tangent to both adjacent lines.Loading:Force loadingConstant pressureLinearly varying pressure (water pressure)GravityRotational speed forcesDisplacement constraints are supportedLoads are stored on geometry primitives (points lines etc) and can be applied before or after meshingExamples:https://github.com/spacether/pycalculix/tree/master/examples
Package: pycalcy
Check it out theWikipycalcyA smooth, lightweight and beautiful library for calculation and moreNowadays this project is being written and rewritten.pipinstallpycalcyFeaturespycalcy contains the following available modules:MathsPhysicsGeometryAstronomyCryptTypical (Global calcs)UsageAfter installing the library, import it in your project like thisimportpycalcyNow you can use the library like thisfrompyacalcyimportGeometry,App# Lets create a new geometry objectgeometry=Geometry()# And main app objectpycalcy=App()# Now we can use it like this to calculate somethingvolume=pycalcy(geometry.volume,6,7)# Now printing the resultprint(volume)ContributingContributeIf you want to contribute to this project you can fork this repository
and make a pull request following the pull request template formatIssuesIf you find a bug or want to request a new feature you can create an issue
Package: pycalendars
pycalendarsPyCalendars helps you to retrieve events from your Google and ICloud calendars, in python.Getting StartedGoogle calendarThe google calendar api requires that you create a project in google developer console (https://console.developers.google.com/) and retrieve credentials.
Depending on what type of application you plan to develop and how you want to use the calendar, you may either want to get credentials for a web / desktop application or for a service account.ICloudICloud only requires your apple id username and password. However, depending on how your account is configured, you may need to use a 2FA verification code.
Package: py-calendars
py_calendarsThis package show the calendar view on the terminal when  you give the year and month also give the satring position of month and yearAfter install the package import the modulefrom py_calendars import calendars

calendar(2005,'jan')In terminal you get the out putJanuary 2005 

 sun   mon  tus  wed  thr  fri  sat 

                                01
  02   03   04   05   06   07   08
  09   10   11   12   13   14   15
  16   17   18   19   20   21   22
  23   24   25   26   27   28   29
  30   31About  packageIn this package thir are three main partFinding the given year starting positionFinding the given month starting positionuse the two resuelt to create the calendar printing designif you want the year starting position import the year_start ( ) functionfrom py_calendars import year_start

print('ans= ', year_start(2005))outputans= 7That means the 2005 January start with 7 position saturdayJanuary 2005 

 sun   mon  tus  wed  thr  fri  sat 

                                01
  02   03   04   05   06   07   08
  09   10   11   12   13   14   15
  16   17   18   19   20   21   22
  23   24   25   26   27   28   29
  30   31if you want the starting month position use month_start ( ) functionfrom py_calendars import month_start


print('ans= ' month_start(2005,'nov'))outputans= 3that mean the 2005 November start with 3 position TuesdayNovember 2005 

 sun   mon  tus  wed  thr  fri  sat 

            01   02   03   04   05
  06   07   08   09   10   11   12
  13   14   15   16   17   18   19
  20   21   22   23   24   25   26
  27   28   29   30
Package: pycalf
pycalf: Causal Inference LibraryA library to make causal inference easier by using PythonGetting StartedInstallingpipinstallpycalfExampleInference with IPWfrompycalfimportmetricsfrompycalf.propensity_scoreimportIPW# Load Data and Define Variablesdf=pd.read_csv('sample/q_data_x.csv')covariate_cols=['TVwatch_day','age','sex','marry_dummy','child_dummy','inc','pmoney','area_kanto','area_tokai','area_keihanshin','job_dummy1','job_dummy2','job_dummy3','job_dummy4','job_dummy5','job_dummy6','job_dummy7','fam_str_dummy1','fam_str_dummy2','fam_str_dummy3','fam_str_dummy4']outcome_cols=['gamecount','gamedummy','gamesecond']treatment_col='cm_dummy'X=df[covariate_cols]y=df[outcome_cols]treatment=df[treatment_col].astype(bool).to_numpy()# Define and Fit IPW Model.learner=Pipeline([('sclaer',preprocessing.MinMaxScaler()),('clf',LogisticRegression(solver='lbfgs',max_iter=1000,random_state=42))])model=IPW(learner)model.fit(X,treatment)# metricsprint('F1 Score: ',metrics.f1_score(treatment,model.get_score(),threshold='auto'))metrics.plot_roc_curve(treatment,model.get_score())metrics.plot_probability_distribution(treatment,model.get_score())# Estimate ATEoutcome_name='gamesecond'z0,z1,treat_effect=model.estimate_effect(X,treatment,y[outcome_name].to_numpy().reshape(-1,1),mode='ate')metrics.plot_treatment_effect(outcome_name,z0[0],z1[0],treat_effect[0].round())Effect size d.Propensity Score DistributionAverage Treatment EffectExport requirements.txtpoetryexport-frequirements.txt--outputdocs/requirements.txtContributingPlease readCONTRIBUTING.mdfor details on our code of conduct, and the process for submitting pull requests to us.AuthorsKonumaru- Initial workAcknowledgmentsUber / causalml:https://github.com/uber/causalmlIwanami Data Science Vol．3:https://www.iwanami.co.jp/book/b243764.html
Package: pycalib
PyCalibPython library for classifier calibrationUser installationThe PyCalib package can be installed from Pypi with the commandpip install pycalibDocumentationThe documentation can be found athttps://classifier-calibration.github.io/PyCalib/DevelopmentThere is a make file to automate some of the common tasks during development.
After downloading the repository create the virtual environment with the
commandmake venvThis will create avenvfolder in your current folder. The environment needs
to be loaded out of the makefile withsource venv/bin/activateAfter the environment is loaded, all dependencies can be installed withmake requirements-devUnittestUnittests are specified as doctest examples in simple functions (see example ),
and more complex tests in their own python files starting withtest_(see
example ).Run the unittest with the commandmake testThe test will show a unittest result including the coverage of the code.
Ideally we want to increase the coverage to cover most of the library.Contiunous IntegrationEvery time a commit is pushed to the master branch a unittest is run following
the workflow.github/workflows/ci.yml. The CI badge
in the README file will show if the test has passed or not.Analyse codeWe are trying to follow the same code standards as inNumpyandScikit-learn, it is possible to check for pep8 and other code
conventions withmake code-analysisDocumentationThe documentation can be found athttps://www.classifier-calibration.com/PyCalib/,
and it is automatically updated after every push to the master branch.All documentation is done ussing theSphinx documentation
generator.  The documentation is written inreStructuredText(*.rst) files in thedocs/sourcefolder. We try to
follow the conventions fromNumpyandScikit-learn.The examples with images in folderdocs/source/examplesare generated
automatically withSphinx-galleryfrom the python code in folderexamples/starting withxmpl_{example_name}.py.The docuemnation can be build with the commandmake doc(Keep in mind that the documentation has its own Makefile inside folderdocs).After building the documentation, a new folder should appear indocs/build/with anindex.htmlthat can be opened locally for further exploration.The documentation is always build and deployed every time a new commit is
pushed to the master branch with the workflow.github/workflows/documentation.yml.After building, thedocs/build/htmlfolder is pushed to the branchgh-pages.Check ReadmeIt is possible to check that the README file passes some tests for Pypi by
runningmake check-readmeUpload to PyPiAfter testing that the code passes all unittests and upgrading the version in
the filepycalib/__init__.pythe code can be published in Pypi with the
following command:make pypiIt may require user and password if these are not set in your home directory a
file.pypirc[pypi]
username = __token__
password = pypi-yourtokenContributorsThis code has been adapted by Miquel from several previous codes. The following
is a list of people that has been involved in some parts of the code.Miquel Perello NietoHao SongTelmo Silva FilhoMarkus Kängsepp
Package: pycalibrate
pycalibratePycalibrate is a Python package that allows access to theCalibratetool. Calibrate is a visual analytics tool used to analyze model calibration in Jupyter Notebooks. Below, we show what Calibrate looks like in practice.InstallationInstalling pycalibrate is easy. Simply run:pipinstallpycalibrateYou can also use pycalibrate on Colab, by copying ourExample Colab Notebook.You can also pip install directly from the repository by runningpip install git+https://github.com/VIDA-NYU/pycalibrateUsageOne can pycalibrate in just a few lines of code:frompycalibrateimportCalibratec=Calibrate(data=dataset)# `dataset` must be a Pandas dataframec.add_model(y_preds,y_labels,"ModelName")# y_preds is an n x k matrix of predictions# y_labels is an n x k matrix of one-hot encoded labelsc.visualize()# Voila!Calibrate ToolNeed Help?Need help? Open up anissue.
Package: pycalib-rt
VersionThis document is for version 0.1.0 of calib_rt.Calib-RTCalib-RT is an open-source Python software package designed for RT (retention time) calibration.
This package provides a flexible and robust solution for achieving accurate RT calibration across various data scales while handling a certain level of noise interference.The workflow diagram is below, providing an overview of the process. For a comprehensive and in-depth explanation, please refer to the associated paper for detailed insights and analysis.InstallationTo use calib_rt, make sure you have the following dependencies installed:Python (>= 3.10)numpy (>= 1.26.0)pandas (>= 2.1.1)networkx (>= 3.1)statsmodels (>= 0.14.0)scipy (>= 1.11.3)You can install the calib_rt package using pip:pipinstallpycalib_rtUsageHere is an example of how to use Calib-RT for retention time calibration:importcalib_rt# basic information of all built-in datasetscalib_rt.RTdatasets.get_datasets_list()sample_typedatasets_num0distort_left21distort_right22exp23linear24S2# use first of "S" type datasetsdatasets=calib_rt.RTdatasets.get_pandas(sample_type="S",index_in_group=1)x=datasets["Spectral library RT"]y=datasets["Measured RT"]# fit and predictmodel=calib_rt.Calib_RT()model.fit(x,y)y_pred=model.predict(x)Performance testFor a detailed analysis of the test conclusion and all performance test results, please refer to the full paper.Referenceslink of paperLicenseThis project is licensed under the MIT License. See the LICENSE file for details.